npm - @nudojs/harvester - Versions diffs - 0.2.8-beta.0 → 1.0.0-beta.1 - Mend

@nudojs/harvester 0.2.8-beta.0 → 1.0.0-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js CHANGED Viewed

@@ -1,6 +1,6 @@
-// src/index.ts
-import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import ts2 from "typescript";
+// src/harvest-dts.ts
+import { readFileSync, statSync } from "fs";
+import ts from "typescript";
 import {
   abs as makeAbs,
   lit as termLit,
@@ -14,415 +14,70 @@ import {
   getFnImpl,
   substAbs
 } from "@nudojs/core";
-// src/dts-contract-draft.ts
-import { readFileSync, existsSync, statSync, readdirSync } from "fs";
-import { basename, dirname, join } from "path";
-import ts from "typescript";
-var BUILDERS = [
-  "fn",
-  "number",
-  "string",
-  "boolean",
-  "any",
-  "shape",
-  "array",
-  "lit",
-  "union"
-];
-function keywordDsl(node) {
-  switch (node.kind) {
-    case ts.SyntaxKind.NumberKeyword:
-      return "number()";
-    case ts.SyntaxKind.StringKeyword:
-      return "string()";
-    case ts.SyntaxKind.BooleanKeyword:
-      return "boolean()";
-    case ts.SyntaxKind.AnyKeyword:
-    case ts.SyntaxKind.UnknownKeyword:
-    case ts.SyntaxKind.VoidKeyword:
-    case ts.SyntaxKind.UndefinedKeyword:
-    case ts.SyntaxKind.NullKeyword:
-    case ts.SyntaxKind.ObjectKeyword:
-    case ts.SyntaxKind.NeverKeyword:
-      return "any()";
-    case ts.SyntaxKind.BigIntKeyword:
-    case ts.SyntaxKind.SymbolKeyword:
-      return void 0;
-    default:
-      return void 0;
-  }
+var MAX_ALIAS_DEPTH = 8;
+function scopeKey(scope) {
+  return scope.moduleName ?? "\0global";
 }
-function litDsl(node) {
-  const lit = node.literal;
-  if (ts.isStringLiteral(lit)) return `lit(${JSON.stringify(lit.text)})`;
-  if (ts.isNumericLiteral(lit)) return `lit(${lit.text})`;
-  if (lit.kind === ts.SyntaxKind.TrueKeyword) return "lit(true)";
-  if (lit.kind === ts.SyntaxKind.FalseKeyword) return "lit(false)";
-  return void 0;
+function absExact(shape) {
+  return makeAbs(shape, void 0, void 0, "exact");
 }
-function typeRefName(node) {
-  const n = node.typeName;
-  if (ts.isIdentifier(n)) return n.text;
-  if (ts.isQualifiedName(n)) {
-    const parts = [];
-    let cur = n;
-    while (ts.isQualifiedName(cur)) {
-      parts.unshift(cur.right.text);
-      cur = cur.left;
-    }
-    if (ts.isIdentifier(cur)) parts.unshift(cur.text);
-    return parts.join(".");
-  }
-  return "?";
+function absNever() {
+  return absExact({ k: "never" });
 }
-function typeToDsl(node, depth = 0) {
-  if (!node || depth > 6) return "any()";
-  const kw = keywordDsl(node);
-  if (kw !== void 0) return kw;
-  if (ts.isLiteralTypeNode(node)) {
-    return litDsl(node) ?? "any()";
-  }
-  if (ts.isArrayTypeNode(node)) {
-    const el = typeToDsl(node.elementType, depth + 1) ?? "any()";
-    return `array(${el})`;
-  }
-  if (ts.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 (ts.isParenthesizedTypeNode(node)) {
-    return typeToDsl(node.type, depth + 1);
-  }
-  if (ts.isTypeLiteralNode(node)) {
-    const fields = [];
-    for (const m of node.members) {
-      if (!ts.isPropertySignature(m)) continue;
-      const key = m.name && (ts.isIdentifier(m.name) || ts.isStringLiteral(m.name)) ? ts.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 (ts.isFunctionTypeNode(node) || ts.isConstructorTypeNode(node)) {
-    return fnSignatureDsl(node.parameters, node.type, depth);
-  }
-  if (ts.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 (ts.isExpressionWithTypeArguments(node)) {
-    return void 0;
-  }
-  return void 0;
+function absUnknown() {
+  return makeAbs({ k: "unknown" }, void 0, void 0, "partial");
 }
-function fnSignatureDsl(params, ret, depth) {
-  const fields = [];
-  const notes = [];
-  params.forEach((p, i) => {
-    let name;
-    if (p.name && ts.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}`);
+function absPrim(type) {
+  return absExact({ k: "prim", type });
+}
+function absNullLit() {
+  return makeAbs({ k: "unknown" }, termLit(null), void 0, "exact");
+}
+function absUndefLit() {
+  return makeAbs({ k: "unknown" }, termLit(void 0), void 0, "exact");
+}
+function absLit(value) {
+  if (typeof value === "number") return numLit(value);
+  if (typeof value === "string") return strLit(value);
+  if (typeof value === "boolean") return boolLit(value);
+  if (typeof value === "bigint") return absPrim("bigint");
+  if (value === null) return absNullLit();
+  return absUndefLit();
+}
+function absArr(element) {
+  return absExact({ k: "arr", 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
+    })
   });
-  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 && ts.isIdentifier(decl.name) ? decl.name.text : void 0;
+function absSetType(name, elem) {
+  return absExact({
+    k: "brand",
+    name,
+    shape: absObj({
+      __elem: elem
+    })
+  });
 }
-function collectExports(sourceFile) {
-  const out = [];
-  const push = (e) => {
-    out.push(e);
-  };
-  for (const stmt of sourceFile.statements) {
-    if ((ts.isFunctionDeclaration(stmt) || ts.isMethodSignature(stmt)) && stmt.modifiers?.some((m) => m.kind === ts.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 (ts.isFunctionDeclaration(stmt) && pickName(stmt)) {
-      const isExport = stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
-      if (!isExport) continue;
-      const name = pickName(stmt);
-      push({ name, dsl: fnSignatureDsl(stmt.parameters, stmt.type, 0), kind: "function" });
-      continue;
-    }
-    if (ts.isVariableStatement(stmt)) {
-      const isExport = stmt.modifiers?.some((m) => m.kind === ts.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 (ts.isClassDeclaration(stmt)) {
-      const isExport = stmt.modifiers?.some((m) => m.kind === ts.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 (ts.isMethodDeclaration(m) || ts.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 (ts.isExportAssignment(stmt)) {
-      push({ name: "default", note: "export assignment \u2014 bind via sidecar default", kind: "other" });
-      continue;
-    }
-    if (ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) {
-      continue;
-    }
+function absObj(properties) {
+  const slots = {};
+  for (const [k, v] of Object.entries(properties)) {
+    slots[k] = { value: v };
   }
-  return out;
+  return objOf(slots);
 }
-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 = statSync(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 = statSync(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 = readFileSync(file, "utf8");
-    } catch {
-      skippedFiles++;
-      continue;
-    }
-    const sf = ts.createSourceFile(file, content, ts.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/index.ts
-var MAX_ALIAS_DEPTH = 8;
-function scopeKey(scope) {
-  return scope.moduleName ?? "\0global";
-}
-function absExact(shape) {
-  return makeAbs(shape, void 0, void 0, "exact");
-}
-function absNever() {
-  return absExact({ k: "never" });
-}
-function absUnknown() {
-  return makeAbs({ k: "unknown" }, void 0, void 0, "partial");
-}
-function absPrim(type) {
-  return absExact({ k: "prim", type });
-}
-function absNullLit() {
-  return makeAbs({ k: "unknown" }, termLit(null), void 0, "exact");
-}
-function absUndefLit() {
-  return makeAbs({ k: "unknown" }, termLit(void 0), void 0, "exact");
-}
-function absLit(value) {
-  if (typeof value === "number") return numLit(value);
-  if (typeof value === "string") return strLit(value);
-  if (typeof value === "boolean") return boolLit(value);
-  if (typeof value === "bigint") return absPrim("bigint");
-  if (value === null) return absNullLit();
-  return absUndefLit();
-}
-function absArr(element) {
-  return absExact({ k: "arr", 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)) {
-    slots[k] = { value: v };
-  }
-  return objOf(slots);
-}
-function absBrand(name, properties) {
-  return absExact({ k: "brand", name, shape: absObj(properties) });
+function absBrand(name, properties) {
+  return absExact({ k: "brand", name, shape: absObj(properties) });
 }
 function absFnSig(paramTypes, returnType, extra) {
   return relationFn(paramTypes, returnType, {
@@ -483,17 +138,17 @@ function harvestDts(files, opts) {
     }
     let content;
     try {
-      const st = statSync2(file);
+      const st = statSync(file);
       if (st.size > maxBytes) {
         ctx.skipped++;
         continue;
       }
-      content = readFileSync2(file, "utf8");
+      content = readFileSync(file, "utf8");
     } catch {
       ctx.skipped++;
       continue;
     }
-    const sourceFile = ts2.createSourceFile(file, content, ts2.ScriptTarget.Latest, true);
+    const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
     collectStatements(ctx, sourceFile.statements, { moduleName: void 0, ns: [] });
     parsed++;
   }
@@ -569,13 +224,13 @@ function collectStatements(ctx, statements, scope) {
   }
 }
 function collectStatement(ctx, stmt, scope) {
-  if (ts2.isModuleDeclaration(stmt)) {
+  if (ts.isModuleDeclaration(stmt)) {
     const body = stmt.body;
-    if (!body || !ts2.isModuleBlock(body)) {
+    if (!body || !ts.isModuleBlock(body)) {
       ctx.skipped++;
       return;
     }
-    if (ts2.isStringLiteral(stmt.name)) {
+    if (ts.isStringLiteral(stmt.name)) {
       ctx.declaredModules.add(stmt.name.text);
       collectStatements(ctx, body.statements, { moduleName: stmt.name.text, ns: [] });
     } else if (stmt.name.text === "global") {
@@ -585,7 +240,7 @@ function collectStatement(ctx, stmt, scope) {
     }
     return;
   }
-  if (ts2.isFunctionDeclaration(stmt)) {
+  if (ts.isFunctionDeclaration(stmt)) {
     if (!stmt.name) {
       ctx.skipped++;
       return;
@@ -600,13 +255,13 @@ function collectStatement(ctx, stmt, scope) {
     ctx.symbols++;
     return;
   }
-  if (ts2.isVariableStatement(stmt)) {
+  if (ts.isVariableStatement(stmt)) {
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts2.isIdentifier(decl.name)) {
+      if (!ts.isIdentifier(decl.name)) {
         ctx.skipped++;
         continue;
       }
-      const ifaceName = decl.type && ts2.isTypeReferenceNode(decl.type) ? typeNameString(decl.type.typeName) : void 0;
+      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",
@@ -624,15 +279,15 @@ function collectStatement(ctx, stmt, scope) {
     }
     return;
   }
-  if (ts2.isInterfaceDeclaration(stmt)) {
+  if (ts.isInterfaceDeclaration(stmt)) {
     registerTypeDecl(ctx, scope, stmt.name.text, stmt);
     return;
   }
-  if (ts2.isTypeAliasDeclaration(stmt)) {
+  if (ts.isTypeAliasDeclaration(stmt)) {
     registerAlias(ctx, scope, stmt);
     return;
   }
-  if (ts2.isClassDeclaration(stmt)) {
+  if (ts.isClassDeclaration(stmt)) {
     if (!stmt.name) {
       ctx.skipped++;
       return;
@@ -643,18 +298,18 @@ function collectStatement(ctx, stmt, scope) {
     ctx.symbols++;
     return;
   }
-  if (ts2.isEnumDeclaration(stmt)) {
+  if (ts.isEnumDeclaration(stmt)) {
     if (stmt.name) {
       ctx.pending.push({ t: "enum", scope, name: stmt.name.text });
       ctx.symbols++;
     }
     return;
   }
-  if (ts2.isImportDeclaration(stmt)) {
+  if (ts.isImportDeclaration(stmt)) {
     return;
   }
-  if (ts2.isImportEqualsDeclaration(stmt)) {
-    if (ts2.isIdentifier(stmt.name) && stmt.moduleReference && ts2.isExternalModuleReference(stmt.moduleReference) && ts2.isStringLiteral(stmt.moduleReference.expression)) {
+  if (ts.isImportEqualsDeclaration(stmt)) {
+    if (ts.isIdentifier(stmt.name) && stmt.moduleReference && ts.isExternalModuleReference(stmt.moduleReference) && ts.isStringLiteral(stmt.moduleReference.expression)) {
       const key = scopeKey(scope);
       let bindings = ctx.importEquals.get(key);
       if (!bindings) {
@@ -665,10 +320,10 @@ function collectStatement(ctx, stmt, scope) {
     }
     return;
   }
-  if (ts2.isExportDeclaration(stmt)) {
+  if (ts.isExportDeclaration(stmt)) {
     const specifier = stmt.moduleSpecifier;
-    if (specifier && ts2.isStringLiteral(specifier)) {
-      if (stmt.exportClause && ts2.isNamespaceExport(stmt.exportClause)) {
+    if (specifier && ts.isStringLiteral(specifier)) {
+      if (stmt.exportClause && ts.isNamespaceExport(stmt.exportClause)) {
         ctx.skipped++;
         return;
       }
@@ -681,7 +336,7 @@ function collectStatement(ctx, stmt, scope) {
       ctx.skipped++;
       return;
     }
-    if (stmt.exportClause && ts2.isNamedExports(stmt.exportClause)) {
+    if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
       for (const el of stmt.exportClause.elements) {
         const localName = (el.propertyName ?? el.name).text;
         const exportedName = el.name.text;
@@ -693,635 +348,1997 @@ function collectStatement(ctx, stmt, scope) {
           ctx.skipped++;
         }
       }
-      return;
-    }
-    ctx.skipped++;
-    return;
-  }
-  if (ts2.isExportAssignment(stmt)) {
-    if (stmt.expression && ts2.isIdentifier(stmt.expression) && scope.moduleName !== void 0) {
-      const target = ctx.importEquals.get(scopeKey(scope))?.get(stmt.expression.text);
-      if (target !== void 0) {
-        ctx.moduleAliases.push([scope.moduleName, target]);
-        return;
+      return;
+    }
+    ctx.skipped++;
+    return;
+  }
+  if (ts.isExportAssignment(stmt)) {
+    if (stmt.expression && ts.isIdentifier(stmt.expression) && scope.moduleName !== void 0) {
+      const target = ctx.importEquals.get(scopeKey(scope))?.get(stmt.expression.text);
+      if (target !== void 0) {
+        ctx.moduleAliases.push([scope.moduleName, target]);
+        return;
+      }
+    }
+    ctx.skipped++;
+    return;
+  }
+  ctx.skipped++;
+}
+function registerTypeDecl(ctx, scope, 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) push(ctx.qualifiedInterfaces, qualified);
+}
+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, 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;
+      }
+      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;
+  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) 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 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 s of sigs) {
+          if (s.shape.k !== "fn") continue;
+          const ret = s.shape.returnType;
+          if (ret && !isPlainUnknown(ret)) returns.push(ret);
+        }
+        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;
+    }
+    if (rec[p.name] !== void 0) continue;
+    switch (p.t) {
+      case "var": {
+        const mapped = p.typeNode ? mapType(ctx, p.typeNode, 0) : absUnknown();
+        if (isPlainUnknown(mapped)) {
+          ctx.skipped++;
+          break;
+        }
+        rec[p.name] = mapped;
+        break;
+      }
+      case "value": {
+        const cls = ctx.classes.get(p.lookup ?? p.name);
+        if (cls) {
+          const ctor = cls.members.find(ts.isConstructorDeclaration);
+          const params = [];
+          if (ctor) {
+            for (const param of ctor.parameters) {
+              let type = param.type ? mapType(ctx, param.type, 0) : absUnknown();
+              if (param.questionToken) type = absUnion([type, absUndefLit()]);
+              params.push(type);
+            }
+          }
+          rec[p.name] = absFnSig(params, instanceFor(ctx, p.lookup ?? p.name));
+        } else {
+          rec[p.name] = instanceFor(ctx, p.lookup ?? p.name);
+        }
+        break;
+      }
+      case "enum":
+        rec[p.name] = absUnknown();
+        break;
+    }
+  }
+  for (const [alias, target] of ctx.moduleAliases) {
+    if (ctx.modules[target] && !ctx.modules[alias]) {
+      ctx.modules[alias] = ctx.modules[target];
+    }
+  }
+}
+function typeNameString(name) {
+  if (ts.isIdentifier(name)) return name.text;
+  return `${typeNameString(name.left)}.${name.right.text}`;
+}
+function memberName(node) {
+  const n = node.name;
+  if (!n) return void 0;
+  if (ts.isIdentifier(n) || ts.isStringLiteral(n) || ts.isNumericLiteral(n)) return n.text;
+  return void 0;
+}
+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 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 {
+    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);
+  }
+  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 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 = {};
+  for (const member of members) {
+    if (ts.isPropertySignature(member)) {
+      const name = memberName(member);
+      if (name === void 0) continue;
+      let type = member.type ? mapType(ctx, member.type, depth) : absUnknown();
+      if (member.questionToken) type = absUnion([type, absUndefLit()]);
+      properties[name] = type;
+    } else if (ts.isMethodSignature(member)) {
+      const name = memberName(member);
+      if (name === void 0 || properties[name] !== void 0) continue;
+      properties[name] = signatureToFnSig(ctx, member);
+    }
+  }
+  return properties;
+}
+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, args.map((a) => mapType(ctx, a, depth)));
+  }
+  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);
+  if (ts.isTypeReferenceNode(node)) return mapTypeRef(ctx, node, depth);
+  if (ts.isArrayTypeNode(node)) return absArr(mapType(ctx, node.elementType, depth));
+  if (ts.isTupleTypeNode(node)) {
+    for (const element of node.elements) {
+      const inner = ts.isNamedTupleMember(element) ? element.type : element;
+      return absArr(mapType(ctx, inner, depth));
+    }
+    return absUnknown();
+  }
+  if (ts.isUnionTypeNode(node)) {
+    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));
+    if (members.length > 0 && members.every((m) => m.shape.k === "obj")) {
+      const properties = {};
+      for (const member of members) {
+        if (member.shape.k !== "obj") continue;
+        for (const [k, slot] of Object.entries(member.shape.slots)) {
+          properties[k] = slot.value;
+        }
+      }
+      return absObj(properties);
+    }
+    return members[0] ?? absUnknown();
+  }
+  if (ts.isLiteralTypeNode(node)) {
+    const lit = node.literal;
+    if (ts.isStringLiteral(lit)) return absLit(lit.text);
+    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));
+    }
+    return absUnknown();
+  }
+  if (ts.isFunctionTypeNode(node)) return signatureToFnSig(ctx, node);
+  if (ts.isTypeLiteralNode(node)) {
+    const ctor = node.members.find(ts.isConstructSignatureDeclaration);
+    if (ctor) {
+      const params = [];
+      for (const param of ctor.parameters) {
+        let type = param.type ? mapType(ctx, param.type, depth) : absUnknown();
+        if (param.questionToken) type = absUnion([type, absUndefLit()]);
+        params.push(type);
+      }
+      return absFnSig(params, ctor.type ? mapType(ctx, ctor.type, depth) : absUnknown());
+    }
+    return absObj(mapTypeMembers(ctx, node.members, 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");
+    case ts.SyntaxKind.NumberKeyword:
+      return absPrim("number");
+    case ts.SyntaxKind.BooleanKeyword:
+      return absPrim("boolean");
+    case ts.SyntaxKind.BigIntKeyword:
+      return absPrim("bigint");
+    case ts.SyntaxKind.SymbolKeyword:
+      return absPrim("symbol");
+    case ts.SyntaxKind.AnyKeyword:
+    case ts.SyntaxKind.UnknownKeyword:
+    case ts.SyntaxKind.ObjectKeyword:
+      return absUnknown();
+    case ts.SyntaxKind.VoidKeyword:
+    case ts.SyntaxKind.UndefinedKeyword:
+      return absUndefLit();
+    case ts.SyntaxKind.NeverKeyword:
+      return absNever();
+    case ts.SyntaxKind.NullKeyword:
+      return absNullLit();
+    default:
+      return absUnknown();
+  }
+}
+function indent(level) {
+  return "  ".repeat(level);
+}
+function emitKey(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function emitEntries(lines, record, level) {
+  for (const [key, value] of Object.entries(record)) {
+    lines.push(`${indent(level)}${emitKey(key)}: ${emitAbs(value, /* @__PURE__ */ new Set())},`);
+  }
+}
+function emitAbs(a, expanding) {
+  const s = a.shape;
+  switch (s.k) {
+    case "never":
+      return "absNever";
+    case "unknown":
+      if (a.term?.op === "lit") {
+        const v = a.term.value;
+        if (v === null) return `makeAbs({ k: "unknown" }, { op: "lit", value: null }, undefined, "exact")`;
+        if (v === void 0) return `makeAbs({ k: "unknown" }, { op: "lit", value: undefined }, undefined, "exact")`;
+        if (typeof v === "number") return `numLit(${JSON.stringify(v)})`;
+        if (typeof v === "boolean") return `boolLit(${v})`;
+        if (typeof v === "string") return `strLit(${JSON.stringify(v)})`;
+      }
+      return "absUnknown";
+    case "any":
+      return "absUnknown";
+    case "prim": {
+      if (a.term?.op === "lit") {
+        const v = a.term.value;
+        if (typeof v === "number") return `numLit(${JSON.stringify(v)})`;
+        if (typeof v === "boolean") return `boolLit(${v})`;
+        if (typeof v === "string") return `strLit(${JSON.stringify(v)})`;
+      }
+      if (s.type === "number") return "num()";
+      if (s.type === "string") return "str()";
+      if (s.type === "boolean") return "bool()";
+      return "absUnknown";
+    }
+    case "arr":
+      return `makeAbs({ k: "arr", element: ${emitAbs(s.element, expanding)} }, undefined, undefined, "exact")`;
+    case "tuple":
+      return `makeAbs({ k: "tuple", elements: [${s.elements.map((e) => emitAbs(e, expanding)).join(", ")}] }, undefined, undefined, "exact")`;
+    case "eff":
+      return `makeAbs({ k: "eff", eff: ${JSON.stringify(s.eff)}, inner: ${emitAbs(s.inner, expanding)} }, undefined, undefined, "exact")`;
+    case "obj": {
+      const entries = Object.entries(s.slots).map(
+        ([key, slot]) => `${emitKey(key)}: { value: ${emitAbs(slot.value, expanding)} }`
+      );
+      return `objOf({ ${entries.join(", ")} })`;
+    }
+    case "brand": {
+      if (expanding.has(s.name)) {
+        return `makeAbs({ k: "brand", name: ${JSON.stringify(s.name)}, shape: absUnknown }, undefined, undefined, "path")`;
+      }
+      expanding.add(s.name);
+      try {
+        return `makeAbs({ k: "brand", name: ${JSON.stringify(s.name)}, shape: ${emitAbs(s.shape, expanding)} }, undefined, undefined, "path")`;
+      } finally {
+        expanding.delete(s.name);
+      }
+    }
+    case "sum": {
+      if (s.members.length === 0) return "absNever";
+      if (s.members.length === 1) return emitAbs(s.members[0], expanding);
+      return `makeAbs({ k: "sum", members: [${s.members.map((m) => emitAbs(m, expanding)).join(", ")}] }, undefined, undefined, "exact")`;
+    }
+    case "fn": {
+      const pts = s.paramTypes ?? [];
+      const params = pts.map((p) => emitAbs(p, expanding)).join(", ");
+      const ret = s.returnType ? emitAbs(s.returnType, expanding) : "absUnknown";
+      return `relationFn([${params}], ${ret}, { conf: "exact" })`;
+    }
+    default:
+      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;
     }
-    ctx.skipped++;
-    return;
-  }
-  ctx.skipped++;
-}
-function registerTypeDecl(ctx, scope, 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]);
+    if (ts2.isExportAssignment(stmt)) {
+      push({ name: "default", note: "export assignment \u2014 bind via sidecar default", kind: "other" });
+      continue;
     }
-  };
-  push(ctx.interfaces, name);
-  if (ts2.isClassDeclaration(decl)) return;
-  const qualified = [...scope.ns, name].join(".");
-  if (qualified !== name) push(ctx.qualifiedInterfaces, qualified);
-}
-function interfaceDeclsOf(ctx, typeNode) {
-  const name = typeof typeNode === "string" ? typeNode : ts2.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 (ts2.isInterfaceDeclaration(d) && !seen.has(d)) {
-        seen.add(d);
-        out.push(d);
-      }
+    if (ts2.isInterfaceDeclaration(stmt) || ts2.isTypeAliasDeclaration(stmt)) {
+      continue;
     }
   }
   return out;
 }
-function expandInterfaceAsModuleMembers(ctx, scope, ifaces) {
-  for (const iface of ifaces) {
-    for (const member of iface.members) {
-      if (ts2.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;
-      }
-      if (ts2.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 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);
     }
   }
-}
-function registerAlias(ctx, scope, stmt) {
-  const name = stmt.name.text;
-  const push = (map, key) => {
-    const list = map.get(key);
-    if (list) {
-      if (!list.includes(stmt)) list.push(stmt);
-    } else {
-      map.set(key, [stmt]);
+  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;
     }
-  };
-  push(ctx.aliases, name);
-  const qualified = [...scope.ns, name].join(".");
-  if (qualified !== name) push(ctx.qualifiedAliases, qualified);
+    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 materialize(ctx) {
-  const expanded = [];
-  for (const p of ctx.pending) {
-    if (p.t !== "iface-expand") {
-      expanded.push(p);
-      continue;
+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;
     }
-    const ifaces = interfaceDeclsOf(ctx, p.typeRefName);
-    if (ifaces.length === 0) {
-      continue;
+    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);
     }
-    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);
+  };
+  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);
     }
   }
-  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 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 s of sigs) {
-          if (s.shape.k !== "fn") continue;
-          const ret = s.shape.returnType;
-          if (ret && !isPlainUnknown(ret)) returns.push(ret);
-        }
-        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;
+  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;
     }
-    if (rec[p.name] !== void 0) continue;
-    switch (p.t) {
-      case "var": {
-        const mapped = p.typeNode ? mapType(ctx, p.typeNode, 0) : absUnknown();
-        if (isPlainUnknown(mapped)) {
-          ctx.skipped++;
-          break;
-        }
-        rec[p.name] = mapped;
-        break;
-      }
-      case "value": {
-        const cls = ctx.classes.get(p.lookup ?? p.name);
-        if (cls) {
-          const ctor = cls.members.find(ts2.isConstructorDeclaration);
-          const params = [];
-          if (ctor) {
-            for (const param of ctor.parameters) {
-              let type = param.type ? mapType(ctx, param.type, 0) : absUnknown();
-              if (param.questionToken) type = absUnion([type, absUndefLit()]);
-              params.push(type);
-            }
-          }
-          rec[p.name] = absFnSig(params, instanceFor(ctx, p.lookup ?? p.name));
-        } else {
-          rec[p.name] = instanceFor(ctx, p.lookup ?? p.name);
-        }
-        break;
-      }
-      case "enum":
-        rec[p.name] = absUnknown();
-        break;
+    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);
     }
   }
-  for (const [alias, target] of ctx.moduleAliases) {
-    if (ctx.modules[target] && !ctx.modules[alias]) {
-      ctx.modules[alias] = ctx.modules[target];
+  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 typeNameString(name) {
-  if (ts2.isIdentifier(name)) return name.text;
-  return `${typeNameString(name.left)}.${name.right.text}`;
+function dtsPathToContractDraft(path, label) {
+  const files = readDtsFiles([path]);
+  return dtsToContractDraft(files, label ?? basename(path).replace(/\.d\.ts$/, ""));
 }
-function memberName(node) {
-  const n = node.name;
-  if (!n) return void 0;
-  if (ts2.isIdentifier(n) || ts2.isStringLiteral(n) || ts2.isNumericLiteral(n)) return n.text;
+// 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;
 }
-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 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 {
-    for (const d of decls) {
-      const members = d.members;
-      for (const member of members) {
-        const modifiers = member.modifiers;
-        if (modifiers?.some((mod) => mod.kind === ts2.SyntaxKind.StaticKeyword)) continue;
-        if (ts2.isPropertySignature(member) || ts2.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 (ts2.isMethodSignature(member) || ts2.isMethodDeclaration(member)) {
-          const name = memberName(member);
-          if (name === void 0 || properties[name] !== void 0) continue;
-          properties[name] = signatureToFnSig(ctx, member);
-        } else if (ts2.isGetAccessorDeclaration(member) || ts2.isSetAccessorDeclaration(member)) {
-          const name = memberName(member);
-          if (name === void 0 || properties[name] !== void 0 || !member.type) continue;
-          properties[name] = mapType(ctx, member.type, 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);
       }
     }
-  } finally {
-    ctx.typeParams = savedTp;
-    ctx.expanding.delete(key);
-  }
-  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;
+  };
+  walk(root);
+  out.sort((a, b) => dtsPriority(a, root) - dtsPriority(b, root) || a.length - b.length);
+  return out.slice(0, maxFiles);
 }
-function signatureToFnSig(ctx, sig) {
-  const savedTp = ctx.typeParams;
-  ctx.typeParams = new Set(savedTp);
-  for (const tp of sig.typeParameters ?? []) {
-    ctx.typeParams.add(tp.name.text);
-  }
+function entryDtsFromPackageJson(root) {
+  const pj = join2(root, "package.json");
+  if (!existsSync2(pj)) return void 0;
   try {
-    const paramTypes = sig.parameters.map((param) => {
-      let type;
-      if (param.dotDotDotToken) {
-        const inner = param.type && ts2.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();
+    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;
       }
-      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;
+    }
+  } catch {
   }
+  return void 0;
 }
-function mapTypeMembers(ctx, members, depth) {
-  const properties = {};
-  for (const member of members) {
-    if (ts2.isPropertySignature(member)) {
-      const name = memberName(member);
-      if (name === void 0) continue;
-      let type = member.type ? mapType(ctx, member.type, depth) : absUnknown();
-      if (member.questionToken) type = absUnion([type, absUndefLit()]);
-      properties[name] = type;
-    } else if (ts2.isMethodSignature(member)) {
-      const name = memberName(member);
-      if (name === void 0 || properties[name] !== void 0) continue;
-      properties[name] = signatureToFnSig(ctx, member);
+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 properties;
+  return files;
 }
-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, args.map((a) => mapType(ctx, a, depth)));
+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);
   }
-  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();
+  return specs;
 }
-function collectInferNames(node, out = /* @__PURE__ */ new Set()) {
+function collectRequires(node, out) {
   const visit = (n) => {
-    if (!n) return;
-    if (ts2.isInferTypeNode(n)) {
-      out.add(n.typeParameter.name.text);
-      visit(n.typeParameter.constraint);
-      return;
+    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);
     }
-    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";
+// 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 };
   }
-  if (cs.k === "arr" && es.k === "arr") {
-    return absExtends(cs.element, es.element);
+  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" };
   }
-  if (cs.k === "eff" && es.k === "eff" && cs.eff === es.eff) {
-    return absExtends(cs.inner, es.inner);
+}
+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"));
   }
-  if (cs.k === "brand" && es.k === "brand") {
-    return cs.name === es.name ? "true" : "false";
+}
+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;
   }
-  if (cs.k === "never") return "true";
-  return "unknown";
 }
-function matchExtendsInfer(pattern, actual, inferMap, depth = 0) {
-  if (depth > 6) return "unknown";
-  if (ts2.isInferTypeNode(pattern)) {
-    const name = pattern.typeParameter.name.text;
-    if (!inferMap.has(name)) inferMap.set(name, actual);
-    return "true";
+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;
   }
-  if (ts2.isArrayTypeNode(pattern) && actual.shape.k === "arr") {
-    return matchExtendsInfer(pattern.elementType, actual.shape.element, inferMap, depth + 1);
+}
+function readPkgVersion(root) {
+  try {
+    const raw = JSON.parse(readFileSync4(join3(root, "package.json"), "utf8"));
+    return raw.version;
+  } catch {
+    return void 0;
   }
-  if (ts2.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);
+}
+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 "unknown";
-  }
-  if (ts2.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";
+  return h.digest("hex");
 }
-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);
+function diskPath(root, key) {
+  return join3(root, key.slice(0, 2), `${key}.json`);
+}
+function readHarvestDisk(root, key) {
   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;
+    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 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 (ts2.isArrayTypeNode(ext)) {
-    return { fromVar, via: "arr", inferVar };
+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 {
   }
-  if (ts2.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 };
+}
+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;
   }
-  return void 0;
+  if (dtsFiles.length === 0) return null;
+  return { root, dtsFiles, pkgVersion: readPkgVersion(root) };
 }
-function mapType(ctx, node, depth) {
-  if (!node || depth > MAX_ALIAS_DEPTH) return absUnknown();
-  if (ts2.isParenthesizedTypeNode(node)) return mapType(ctx, node.type, depth);
-  if (ts2.isTypeReferenceNode(node)) return mapTypeRef(ctx, node, depth);
-  if (ts2.isArrayTypeNode(node)) return absArr(mapType(ctx, node.elementType, depth));
-  if (ts2.isTupleTypeNode(node)) {
-    for (const element of node.elements) {
-      const inner = ts2.isNamedTupleMember(element) ? element.type : element;
-      return absArr(mapType(ctx, inner, depth));
+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 };
+      }
     }
-    return absUnknown();
   }
-  if (ts2.isUnionTypeNode(node)) {
-    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);
+  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;
   }
-  if (ts2.isIntersectionTypeNode(node)) {
-    const members = node.types.map((t) => mapType(ctx, t, depth));
-    if (members.length > 0 && members.every((m) => m.shape.k === "obj")) {
-      const properties = {};
-      for (const member of members) {
-        if (member.shape.k !== "obj") continue;
-        for (const [k, slot] of Object.entries(member.shape.slots)) {
-          properties[k] = slot.value;
-        }
-      }
-      return absObj(properties);
+  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);
     }
-    return members[0] ?? absUnknown();
+    this.map.delete(key);
+    this.map.set(key, value);
   }
-  if (ts2.isLiteralTypeNode(node)) {
-    const lit = node.literal;
-    if (ts2.isStringLiteral(lit)) return absLit(lit.text);
-    if (ts2.isNumericLiteral(lit)) return absLit(Number(lit.text));
-    if (lit.kind === ts2.SyntaxKind.TrueKeyword) return absLit(true);
-    if (lit.kind === ts2.SyntaxKind.FalseKeyword) return absLit(false);
-    if (lit.kind === ts2.SyntaxKind.NullKeyword) return absNullLit();
-    if (ts2.isPrefixUnaryExpression(lit) && lit.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(lit.operand)) {
-      return absLit(-Number(lit.operand.text));
+  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);
     }
-    return absUnknown();
   }
-  if (ts2.isFunctionTypeNode(node)) return signatureToFnSig(ctx, node);
-  if (ts2.isTypeLiteralNode(node)) {
-    const ctor = node.members.find(ts2.isConstructSignatureDeclaration);
-    if (ctor) {
-      const params = [];
-      for (const param of ctor.parameters) {
-        let type = param.type ? mapType(ctx, param.type, depth) : absUnknown();
-        if (param.questionToken) type = absUnion([type, absUndefLit()]);
-        params.push(type);
-      }
-      return absFnSig(params, ctor.type ? mapType(ctx, ctor.type, depth) : absUnknown());
+};
+// 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 absObj(mapTypeMembers(ctx, node.members, depth));
+    return [...names];
+  } catch {
+    return [];
   }
-  if (ts2.isTypeOperatorNode(node)) {
-    return node.operator === ts2.SyntaxKind.ReadonlyKeyword ? mapType(ctx, node.type, depth) : absUnknown();
+}
+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;
   }
-  if (ts2.isConditionalTypeNode(node)) {
-    return mapConditionalType(ctx, node, depth);
+  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 } : {}
+      })
+    );
   }
-  if (ts2.isInferTypeNode(node)) {
-    return typeVarAbs(node.typeParameter.name.text);
+  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 };
+    }
   }
-  switch (node.kind) {
-    case ts2.SyntaxKind.StringKeyword:
-      return absPrim("string");
-    case ts2.SyntaxKind.NumberKeyword:
-      return absPrim("number");
-    case ts2.SyntaxKind.BooleanKeyword:
-      return absPrim("boolean");
-    case ts2.SyntaxKind.BigIntKeyword:
-      return absPrim("bigint");
-    case ts2.SyntaxKind.SymbolKeyword:
-      return absPrim("symbol");
-    case ts2.SyntaxKind.AnyKeyword:
-    case ts2.SyntaxKind.UnknownKeyword:
-    case ts2.SyntaxKind.ObjectKeyword:
-      return absUnknown();
-    case ts2.SyntaxKind.VoidKeyword:
-    case ts2.SyntaxKind.UndefinedKeyword:
-      return absUndefLit();
-    case ts2.SyntaxKind.NeverKeyword:
-      return absNever();
-    case ts2.SyntaxKind.NullKeyword:
-      return absNullLit();
-    default:
-      return absUnknown();
+  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];
 }
-function indent(level) {
-  return "  ".repeat(level);
+// 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 emitKey(key) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+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 emitEntries(lines, record, level) {
-  for (const [key, value] of Object.entries(record)) {
-    lines.push(`${indent(level)}${emitKey(key)}: ${emitAbs(value, /* @__PURE__ */ new Set())},`);
+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 emitAbs(a, expanding) {
-  const s = a.shape;
-  switch (s.k) {
-    case "never":
-      return "absNever";
-    case "unknown":
-      if (a.term?.op === "lit") {
-        const v = a.term.value;
-        if (v === null) return `makeAbs({ k: "unknown" }, { op: "lit", value: null }, undefined, "exact")`;
-        if (v === void 0) return `makeAbs({ k: "unknown" }, { op: "lit", value: undefined }, undefined, "exact")`;
-        if (typeof v === "number") return `numLit(${JSON.stringify(v)})`;
-        if (typeof v === "boolean") return `boolLit(${v})`;
-        if (typeof v === "string") return `strLit(${JSON.stringify(v)})`;
+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);
       }
-      return "absUnknown";
-    case "any":
-      return "absUnknown";
-    case "prim": {
-      if (a.term?.op === "lit") {
-        const v = a.term.value;
-        if (typeof v === "number") return `numLit(${JSON.stringify(v)})`;
-        if (typeof v === "boolean") return `boolLit(${v})`;
-        if (typeof v === "string") return `strLit(${JSON.stringify(v)})`;
+      if (def.modules) {
+        for (const [modName, exports] of Object.entries(def.modules)) {
+          allModules[modName] = { ...allModules[modName], ...exports };
+        }
       }
-      if (s.type === "number") return "num()";
-      if (s.type === "string") return "str()";
-      if (s.type === "boolean") return "bool()";
-      return "absUnknown";
-    }
-    case "arr":
-      return `makeAbs({ k: "arr", element: ${emitAbs(s.element, expanding)} }, undefined, undefined, "exact")`;
-    case "tuple":
-      return `makeAbs({ k: "tuple", elements: [${s.elements.map((e) => emitAbs(e, expanding)).join(", ")}] }, undefined, undefined, "exact")`;
-    case "eff":
-      return `makeAbs({ k: "eff", eff: ${JSON.stringify(s.eff)}, inner: ${emitAbs(s.inner, expanding)} }, undefined, undefined, "exact")`;
-    case "obj": {
-      const entries = Object.entries(s.slots).map(
-        ([key, slot]) => `${emitKey(key)}: { value: ${emitAbs(slot.value, expanding)} }`
-      );
-      return `objOf({ ${entries.join(", ")} })`;
     }
-    case "brand": {
-      if (expanding.has(s.name)) {
-        return `makeAbs({ k: "brand", name: ${JSON.stringify(s.name)}, shape: absUnknown }, undefined, undefined, "path")`;
-      }
-      expanding.add(s.name);
-      try {
-        return `makeAbs({ k: "brand", name: ${JSON.stringify(s.name)}, shape: ${emitAbs(s.shape, expanding)} }, undefined, undefined, "path")`;
-      } finally {
-        expanding.delete(s.name);
+    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;
     }
-    case "sum": {
-      if (s.members.length === 0) return "absNever";
-      if (s.members.length === 1) return emitAbs(s.members[0], expanding);
-      return `makeAbs({ k: "sum", members: [${s.members.map((m) => emitAbs(m, expanding)).join(", ")}] }, undefined, undefined, "exact")`;
-    }
-    case "fn": {
-      const pts = s.paramTypes ?? [];
-      const params = pts.map((p) => emitAbs(p, expanding)).join(", ");
-      const ret = s.returnType ? emitAbs(s.returnType, expanding) : "absUnknown";
-      return `relationFn([${params}], ${ret}, { conf: "exact" })`;
+  }
+  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 } : {}
+        })
+      );
     }
-    default:
-      return "absUnknown";
+    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,
   formatDtsContractDraft,
-  harvestDts
+  formatHarvestSummary,
+  getHarvestCacheSize,
+  getNodeHarvestCacheSize,
+  handwrittenNodeEnv,
+  harvestCacheKey,
+  harvestDts,
+  harvestNodeTypes,
+  harvestPackage,
+  harvestPackageCached,
+  harvestPackageWithDisk,
+  harvestSigToAbs,
+  harvestToAbsModules,
+  harvestedValueToAbs,
+  isHarvestNodeDisabled,
+  loadHarvestEnvFromDisk,
+  lookupHarvested,
+  materializeHarvestJson,
+  packageHarvestToAbsModules,
+  readHarvestDisk,
+  resolvePackageRoot,
+  serializeHarvestJson,
+  summarizeNodeEnv,
+  writeHarvestDisk
 };