@nudojs/harvester 0.2.6 → 0.2.8-beta.0

package/dist/index.d.ts

@@ -1,5 +1,33 @@
 import { Abs } from '@nudojs/core';
 
+type DtsExportDraft = {
+    name: string;
+    /** `fn({ … }, …)` 或值约束 DSL；不可投影 → undefined + note */
+    dsl?: string;
+    note?: string;
+    kind: "function" | "value" | "class" | "other";
+};
+type DtsContractDraft = {
+    label: string;
+    files: string[];
+    exports: DtsExportDraft[];
+    draftSource: string;
+    stats: {
+        files: number;
+        exports: number;
+        skipped: number;
+    };
+};
+/** 组装 `@nudo:draft` 模块（与 formatDraftModule 同纪律：不 ambient 绑定）。 */
+declare function formatDtsContractDraft(label: string, files: string[], exports: DtsExportDraft[]): string;
+/**
+ * 从 .d.ts 路径列表生成契约草稿（不写盘）。
+ * `label` 用于头注释（包名或描述）。
+ */
+declare function dtsToContractDraft(dtsFiles: string[], label?: string): DtsContractDraft;
+/** 目录/文件入口：内部解析 .d.ts 列表。 */
+declare function dtsPathToContractDraft(path: string, label?: string): DtsContractDraft;
+
 /**
  * Harvested env：Abs 原生（与 EnvDefinition 同形）。
  * 收集与物化全程 Abs，不再经 TypeValue 桥。
@@ -19,4 +47,4 @@ declare function harvestDts(files: string[], opts?: {
 }): HarvestedEnv;
 declare function emitEnvModule(env: HarvestedEnv, pkgName: string): string;
 
-export { type HarvestedEnv, emitEnvModule, harvestDts };
+export { type DtsContractDraft, type DtsExportDraft, type HarvestedEnv, dtsPathToContractDraft, dtsToContractDraft, emitEnvModule, formatDtsContractDraft, harvestDts };

package/dist/index.js

@@ -1,15 +1,364 @@
 // src/index.ts
-import { readFileSync, statSync } from "fs";
-import ts from "typescript";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import ts2 from "typescript";
 import {
   abs as makeAbs,
   lit as termLit,
+  v as termVar,
   numLit,
   strLit,
   boolLit,
   objOf,
-  joinAbs
+  joinAbs,
+  relationFn,
+  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;
+  }
+}
+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 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 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 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}`);
+  });
+  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 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;
+    }
+  }
+  return out;
+}
+function draftExportName(name) {
+  return name.includes(".") ? name.replace(/\./g, "_") : name;
+}
+function formatDtsContractDraft(label, files, exports) {
+  const draftable = exports.filter((e) => e.dsl !== void 0);
+  const used = /* @__PURE__ */ new Set(["fn"]);
+  for (const e of draftable) {
+    for (const b of BUILDERS) {
+      if (new RegExp(`\\b${b}\\b`).test(e.dsl)) used.add(b);
+    }
+  }
+  if (draftable.some((e) => /\bany\s*\(/.test(e.dsl))) used.add("any");
+  const importList = BUILDERS.filter((b) => used.has(b)).join(", ");
+  const lines = [
+    "// @nudo:draft",
+    `// Generated by \`nudo contract --from-dts\` from ${label}`,
+    `// Sources: ${files.map((f) => basename(f)).join(", ")}`,
+    "//",
+    "// Reverse-engineered from TypeScript declarations \u2014 NOT a sidecar contract.",
+    "// This file is never loaded for check. Review each export, then copy it",
+    "// into <target>.nudo.js to accept (that is when obligations go live).",
+    "//",
+    "// After accept: strengthen with Pred builders (number().gt(0) \u2026) \u2014",
+    "// dts cannot express algebraic implications (x>0 \u21D2 x+1>1).",
+    "",
+    `import { ${importList} } from "@nudojs/core";`,
+    ""
+  ];
+  if (draftable.length === 0) {
+    lines.push("// (no projectable exports)");
+    lines.push("");
+  }
+  for (const e of exports) {
+    if (e.dsl === void 0) {
+      lines.push(`// ${e.name} \u2014 skipped (${e.note ?? "unmodeled"})`);
+      continue;
+    }
+    if (e.note) lines.push(`// ${e.name} \u2014 ${e.note}`);
+    else lines.push(`// ${e.name} \u2014 from TypeScript`);
+    lines.push(`export const ${draftExportName(e.name)} = ${e.dsl};`);
+    if (e.name.includes(".")) {
+      lines.push(`//   sidecar key may also be written as \`${e.name}\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function readDtsFiles(paths, maxFiles = 16) {
+  const out = [];
+  const walk = (dir, depth) => {
+    if (depth > 6 || out.length >= maxFiles * 3) return;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (name === "node_modules" || name === "test" || name === "__tests__") continue;
+      const p = join(dir, name);
+      let st;
+      try {
+        st = 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";
@@ -46,6 +395,25 @@ function absArr(element) {
 function absPromise(inner) {
   return absExact({ k: "eff", eff: "promise", inner });
 }
+function absMapType(name, key, value) {
+  return absExact({
+    k: "brand",
+    name,
+    shape: absObj({
+      __key: key,
+      __value: value
+    })
+  });
+}
+function absSetType(name, elem) {
+  return absExact({
+    k: "brand",
+    name,
+    shape: absObj({
+      __elem: elem
+    })
+  });
+}
 function absObj(properties) {
   const slots = {};
   for (const [k, v] of Object.entries(properties)) {
@@ -56,14 +424,16 @@ function absObj(properties) {
 function absBrand(name, properties) {
   return absExact({ k: "brand", name, shape: absObj(properties) });
 }
-function absFnSig(paramTypes, returnType) {
-  return absExact({
-    k: "fn",
+function absFnSig(paramTypes, returnType, extra) {
+  return relationFn(paramTypes, returnType, {
     params: paramTypes.map((_, i) => `_arg${i}`),
-    paramTypes,
-    returnType
+    conf: "exact",
+    ...extra ?? {}
   });
 }
+function typeVarAbs(name) {
+  return makeAbs({ k: "any" }, termVar(name), void 0, "path");
+}
 function absUnion(members) {
   if (members.length === 0) return absNever();
   return members.reduce((acc, m) => joinAbs(acc, m));
@@ -71,6 +441,19 @@ function absUnion(members) {
 function isPlainUnknown(a) {
   return a.shape.k === "unknown" && !(a.term?.op === "lit");
 }
+function hasTypeVar(a, depth = 0) {
+  if (depth > 6) return false;
+  if (a.term?.op === "var") return true;
+  const s = a.shape;
+  if (s.k === "arr") return hasTypeVar(s.element, depth + 1);
+  if (s.k === "tuple") return s.elements.some((e) => hasTypeVar(e, depth + 1));
+  if (s.k === "sum") return s.members.some((m) => hasTypeVar(m, depth + 1));
+  if (s.k === "obj") return Object.values(s.slots).some((sl) => hasTypeVar(sl.value, depth + 1));
+  if (s.k === "fn") {
+    return (s.paramTypes ?? []).some((p) => hasTypeVar(p, depth + 1)) || (s.returnType ? hasTypeVar(s.returnType, depth + 1) : false);
+  }
+  return false;
+}
 function harvestDts(files, opts) {
   const maxBytes = opts?.maxFileBytes ?? 15e5;
   const deadline = opts?.maxMs !== void 0 ? Date.now() + opts.maxMs : void 0;
@@ -84,6 +467,7 @@ function harvestDts(files, opts) {
     classes: /* @__PURE__ */ new Map(),
     instanceCache: /* @__PURE__ */ new Map(),
     expanding: /* @__PURE__ */ new Set(),
+    typeParams: /* @__PURE__ */ new Set(),
     moduleAliases: [],
     importEquals: /* @__PURE__ */ new Map(),
     declaredModules: /* @__PURE__ */ new Set(),
@@ -99,17 +483,17 @@ function harvestDts(files, opts) {
     }
     let content;
     try {
-      const st = statSync(file);
+      const st = statSync2(file);
       if (st.size > maxBytes) {
         ctx.skipped++;
         continue;
       }
-      content = readFileSync(file, "utf8");
+      content = readFileSync2(file, "utf8");
     } catch {
       ctx.skipped++;
       continue;
     }
-    const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+    const sourceFile = ts2.createSourceFile(file, content, ts2.ScriptTarget.Latest, true);
     collectStatements(ctx, sourceFile.statements, { moduleName: void 0, ns: [] });
     parsed++;
   }
@@ -141,7 +525,7 @@ function emitEnvModule(env, pkgName) {
     constLines.push("");
   }
   const lines = [];
-  lines.push("// Auto-generated by nudo harvest \u2014 DO NOT EDIT");
+  lines.push("// Auto-generated by @nudojs/harvester \u2014 DO NOT EDIT");
   lines.push(`// Source package: ${pkgName}`);
   lines.push(
     'import { num, str, bool, never as absNever, unknown as absUnknown, numLit, strLit, boolLit, objOf, relationFn, abs as makeAbs } from "@nudojs/core";'
@@ -185,13 +569,13 @@ function collectStatements(ctx, statements, scope) {
   }
 }
 function collectStatement(ctx, stmt, scope) {
-  if (ts.isModuleDeclaration(stmt)) {
+  if (ts2.isModuleDeclaration(stmt)) {
     const body = stmt.body;
-    if (!body || !ts.isModuleBlock(body)) {
+    if (!body || !ts2.isModuleBlock(body)) {
       ctx.skipped++;
       return;
     }
-    if (ts.isStringLiteral(stmt.name)) {
+    if (ts2.isStringLiteral(stmt.name)) {
       ctx.declaredModules.add(stmt.name.text);
       collectStatements(ctx, body.statements, { moduleName: stmt.name.text, ns: [] });
     } else if (stmt.name.text === "global") {
@@ -201,7 +585,7 @@ function collectStatement(ctx, stmt, scope) {
     }
     return;
   }
-  if (ts.isFunctionDeclaration(stmt)) {
+  if (ts2.isFunctionDeclaration(stmt)) {
     if (!stmt.name) {
       ctx.skipped++;
       return;
@@ -216,15 +600,23 @@ function collectStatement(ctx, stmt, scope) {
     ctx.symbols++;
     return;
   }
-  if (ts.isVariableStatement(stmt)) {
+  if (ts2.isVariableStatement(stmt)) {
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts.isIdentifier(decl.name)) {
+      if (!ts2.isIdentifier(decl.name)) {
         ctx.skipped++;
         continue;
       }
-      const iface = decl.type ? interfaceDeclOf(ctx, decl.type) : void 0;
-      if (iface) {
-        expandInterfaceAsModuleMembers(ctx, scope, iface);
+      const ifaceName = decl.type && ts2.isTypeReferenceNode(decl.type) ? typeNameString(decl.type.typeName) : void 0;
+      if (ifaceName && (ctx.interfaces.has(ifaceName) || ctx.qualifiedInterfaces.has(ifaceName) || true)) {
+        ctx.pending.push({
+          t: "iface-expand",
+          scope,
+          localName: decl.name.text,
+          typeRefName: ifaceName
+        });
+        ctx.symbols++;
+        ctx.pending.push({ t: "var", scope, name: decl.name.text, typeNode: decl.type });
+        ctx.symbols++;
         continue;
       }
       ctx.pending.push({ t: "var", scope, name: decl.name.text, typeNode: decl.type });
@@ -232,15 +624,15 @@ function collectStatement(ctx, stmt, scope) {
     }
     return;
   }
-  if (ts.isInterfaceDeclaration(stmt)) {
+  if (ts2.isInterfaceDeclaration(stmt)) {
     registerTypeDecl(ctx, scope, stmt.name.text, stmt);
     return;
   }
-  if (ts.isTypeAliasDeclaration(stmt)) {
+  if (ts2.isTypeAliasDeclaration(stmt)) {
     registerAlias(ctx, scope, stmt);
     return;
   }
-  if (ts.isClassDeclaration(stmt)) {
+  if (ts2.isClassDeclaration(stmt)) {
     if (!stmt.name) {
       ctx.skipped++;
       return;
@@ -251,18 +643,18 @@ function collectStatement(ctx, stmt, scope) {
     ctx.symbols++;
     return;
   }
-  if (ts.isEnumDeclaration(stmt)) {
+  if (ts2.isEnumDeclaration(stmt)) {
     if (stmt.name) {
       ctx.pending.push({ t: "enum", scope, name: stmt.name.text });
       ctx.symbols++;
     }
     return;
   }
-  if (ts.isImportDeclaration(stmt)) {
+  if (ts2.isImportDeclaration(stmt)) {
     return;
   }
-  if (ts.isImportEqualsDeclaration(stmt)) {
-    if (ts.isIdentifier(stmt.name) && stmt.moduleReference && ts.isExternalModuleReference(stmt.moduleReference) && ts.isStringLiteral(stmt.moduleReference.expression)) {
+  if (ts2.isImportEqualsDeclaration(stmt)) {
+    if (ts2.isIdentifier(stmt.name) && stmt.moduleReference && ts2.isExternalModuleReference(stmt.moduleReference) && ts2.isStringLiteral(stmt.moduleReference.expression)) {
       const key = scopeKey(scope);
       let bindings = ctx.importEquals.get(key);
       if (!bindings) {
@@ -273,10 +665,10 @@ function collectStatement(ctx, stmt, scope) {
     }
     return;
   }
-  if (ts.isExportDeclaration(stmt)) {
+  if (ts2.isExportDeclaration(stmt)) {
     const specifier = stmt.moduleSpecifier;
-    if (specifier && ts.isStringLiteral(specifier)) {
-      if (stmt.exportClause && ts.isNamespaceExport(stmt.exportClause)) {
+    if (specifier && ts2.isStringLiteral(specifier)) {
+      if (stmt.exportClause && ts2.isNamespaceExport(stmt.exportClause)) {
         ctx.skipped++;
         return;
       }
@@ -289,7 +681,7 @@ function collectStatement(ctx, stmt, scope) {
       ctx.skipped++;
       return;
     }
-    if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+    if (stmt.exportClause && ts2.isNamedExports(stmt.exportClause)) {
       for (const el of stmt.exportClause.elements) {
         const localName = (el.propertyName ?? el.name).text;
         const exportedName = el.name.text;
@@ -306,8 +698,8 @@ function collectStatement(ctx, stmt, scope) {
     ctx.skipped++;
     return;
   }
-  if (ts.isExportAssignment(stmt)) {
-    if (stmt.expression && ts.isIdentifier(stmt.expression) && scope.moduleName !== void 0) {
+  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]);
@@ -320,66 +712,122 @@ function collectStatement(ctx, stmt, scope) {
   ctx.skipped++;
 }
 function registerTypeDecl(ctx, scope, name, decl) {
-  if (!ctx.interfaces.has(name)) ctx.interfaces.set(name, decl);
-  if (ts.isClassDeclaration(decl)) return;
+  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 (ts2.isClassDeclaration(decl)) return;
   const qualified = [...scope.ns, name].join(".");
-  if (qualified !== name && !ctx.qualifiedInterfaces.has(qualified)) {
-    ctx.qualifiedInterfaces.set(qualified, decl);
-  }
+  if (qualified !== name) push(ctx.qualifiedInterfaces, qualified);
 }
-function interfaceDeclOf(ctx, typeNode) {
-  if (!ts.isTypeReferenceNode(typeNode)) return void 0;
-  const name = typeNameString(typeNode.typeName);
-  const d = ctx.interfaces.get(name) ?? ctx.qualifiedInterfaces.get(name);
-  return d && ts.isInterfaceDeclaration(d) ? d : void 0;
+function interfaceDeclsOf(ctx, typeNode) {
+  const name = typeof typeNode === "string" ? typeNode : 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);
+      }
+    }
+  }
+  return out;
 }
-function expandInterfaceAsModuleMembers(ctx, scope, iface) {
-  for (const member of iface.members) {
-    if (ts.isMethodSignature(member)) {
-      const name = memberName(member);
-      if (name === void 0) continue;
-      const existing = ctx.pending.find(
-        (p) => p.t === "fn" && p.name === name && scopeKey(p.scope) === scopeKey(scope)
-      );
-      if (existing && existing.t === "fn") {
-        existing.decls.push(member);
+function expandInterfaceAsModuleMembers(ctx, scope, ifaces) {
+  for (const iface of ifaces) {
+    for (const member of iface.members) {
+      if (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;
       }
-      ctx.pending.push({ t: "fn", scope, name, decls: [member] });
-      ctx.symbols++;
-      continue;
-    }
-    if (ts.isPropertySignature(member)) {
-      const name = memberName(member);
-      if (name === void 0) continue;
-      ctx.pending.push({ t: "var", scope, name, typeNode: member.type });
-      ctx.symbols++;
+      if (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 registerAlias(ctx, scope, stmt) {
   const name = stmt.name.text;
-  if (!ctx.aliases.has(name)) ctx.aliases.set(name, stmt);
+  const push = (map, key) => {
+    const list = map.get(key);
+    if (list) {
+      if (!list.includes(stmt)) list.push(stmt);
+    } else {
+      map.set(key, [stmt]);
+    }
+  };
+  push(ctx.aliases, name);
   const qualified = [...scope.ns, name].join(".");
-  if (qualified !== name && !ctx.qualifiedAliases.has(qualified)) {
-    ctx.qualifiedAliases.set(qualified, stmt);
-  }
+  if (qualified !== name) push(ctx.qualifiedAliases, qualified);
 }
 function materialize(ctx) {
+  const expanded = [];
+  for (const p of ctx.pending) {
+    if (p.t !== "iface-expand") {
+      expanded.push(p);
+      continue;
+    }
+    const ifaces = interfaceDeclsOf(ctx, p.typeRefName);
+    if (ifaces.length === 0) {
+      continue;
+    }
+    const before = ctx.pending.length;
+    expandInterfaceAsModuleMembers(ctx, p.scope, ifaces);
+    for (let i = before; i < ctx.pending.length; i++) {
+      const n = ctx.pending[i];
+      if (n.t === "fn" || n.t === "var") expanded.push(n);
+    }
+  }
+  ctx.pending = expanded;
   for (const p of ctx.pending) {
+    if (p.t === "iface-expand") continue;
     const rec = recordFor(ctx, p.scope);
     if (p.t === "fn") {
       if (rec[p.name] !== void 0) continue;
-      const value = signatureToFnSig(ctx, p.decls[0]);
-      const sig = value.shape.k === "fn" ? value.shape : void 0;
-      if (sig) {
+      const sigs = p.decls.map((d) => signatureToFnSig(ctx, d));
+      const value = sigs[0];
+      const shape0 = value.shape.k === "fn" ? value.shape : void 0;
+      if (shape0 && sigs.length > 1) {
         const returns = [];
-        for (const decl of p.decls) {
-          if (!decl.type) continue;
-          const ret = mapType(ctx, decl.type, 0);
-          if (!isPlainUnknown(ret)) returns.push(ret);
+        for (const s of sigs) {
+          if (s.shape.k !== "fn") continue;
+          const ret = s.shape.returnType;
+          if (ret && !isPlainUnknown(ret)) returns.push(ret);
         }
-        sig.returnType = returns.length > 0 ? absUnion(returns) : absUnknown();
+        const withVars = returns.filter((r) => hasTypeVar(r));
+        const pool = withVars.length > 0 ? withVars : returns;
+        const mergedRet = pool.length > 0 ? absUnion(pool) : absUnknown();
+        shape0.returnType = mergedRet;
+        const rel = getFnImpl(value)?.relation;
+        if (rel) rel.returnType = mergedRet;
       }
       rec[p.name] = value;
       continue;
@@ -398,7 +846,7 @@ function materialize(ctx) {
       case "value": {
         const cls = ctx.classes.get(p.lookup ?? p.name);
         if (cls) {
-          const ctor = cls.members.find(ts.isConstructorDeclaration);
+          const ctor = cls.members.find(ts2.isConstructorDeclaration);
           const params = [];
           if (ctor) {
             for (const param of ctor.parameters) {
@@ -425,78 +873,111 @@ function materialize(ctx) {
   }
 }
 function typeNameString(name) {
-  if (ts.isIdentifier(name)) return name.text;
+  if (ts2.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;
+  if (ts2.isIdentifier(n) || ts2.isStringLiteral(n) || ts2.isNumericLiteral(n)) return n.text;
   return void 0;
 }
-function instanceFor(ctx, key) {
-  const cached = ctx.instanceCache.get(key);
+function instanceFor(ctx, key, typeArgs) {
+  const cacheKey = typeArgs && typeArgs.length > 0 ? `${key}::${typeArgs.length}` : key;
+  const cached = ctx.instanceCache.get(cacheKey);
   if (cached !== void 0) return cached;
-  const decl = ctx.interfaces.get(key) ?? ctx.qualifiedInterfaces.get(key);
+  const decls = interfaceDeclsOf(ctx, key);
+  const decl = decls[0];
   if (!decl) return absUnknown();
   if (ctx.expanding.has(key)) {
     return absBrand(decl.name?.text ?? key, {});
   }
   ctx.expanding.add(key);
+  const savedTp = ctx.typeParams;
+  ctx.typeParams = new Set(savedTp);
+  for (const d of decls) {
+    for (const tp of d.typeParameters ?? []) ctx.typeParams.add(tp.name.text);
+  }
   const properties = {};
   try {
-    const members = decl.members;
-    for (const member of members) {
-      const modifiers = member.modifiers;
-      if (modifiers?.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)) continue;
-      if (ts.isPropertySignature(member) || ts.isPropertyDeclaration(member)) {
-        const name = memberName(member);
-        if (name === void 0) continue;
-        let type = member.type ? mapType(ctx, member.type, 0) : absUnknown();
-        if (member.questionToken) type = absUnion([type, absUndefLit()]);
-        properties[name] = type;
-      } else if (ts.isMethodSignature(member) || ts.isMethodDeclaration(member)) {
-        const name = memberName(member);
-        if (name === void 0 || properties[name] !== void 0) continue;
-        properties[name] = signatureToFnSig(ctx, member);
-      } else if (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) {
-        const name = memberName(member);
-        if (name === void 0 || properties[name] !== void 0 || !member.type) continue;
-        properties[name] = mapType(ctx, member.type, 0);
+    for (const d of decls) {
+      const members = d.members;
+      for (const member of members) {
+        const modifiers = member.modifiers;
+        if (modifiers?.some((mod) => mod.kind === 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);
+        }
       }
     }
   } finally {
+    ctx.typeParams = savedTp;
     ctx.expanding.delete(key);
   }
-  const value = absBrand(decl.name?.text ?? key, properties);
-  ctx.instanceCache.set(key, value);
+  let value = absBrand(decl.name?.text ?? key, properties);
+  if (typeArgs && typeArgs.length > 0 && Object.keys(properties).length <= 40) {
+    const map = /* @__PURE__ */ new Map();
+    const tps = decls[0].typeParameters ?? [];
+    tps.forEach((tp, i) => {
+      const arg = typeArgs[i];
+      if (arg) map.set(tp.name.text, arg);
+    });
+    if (map.size > 0) value = substAbs(value, map);
+  }
+  ctx.instanceCache.set(cacheKey, value);
   return value;
 }
 function signatureToFnSig(ctx, sig) {
-  const paramTypes = sig.parameters.map((param) => {
-    let type;
-    if (param.dotDotDotToken) {
-      const inner = param.type && ts.isArrayTypeNode(param.type) ? param.type.elementType : param.type;
-      type = inner ? absArr(mapType(ctx, inner, 0)) : absUnknown();
-    } else {
-      type = param.type ? mapType(ctx, param.type, 0) : absUnknown();
-    }
-    if (param.questionToken && !param.dotDotDotToken) type = absUnion([type, absUndefLit()]);
-    return type;
-  });
-  const returnType = sig.type ? mapType(ctx, sig.type, 0) : absUnknown();
-  return absFnSig(paramTypes, returnType);
+  const savedTp = ctx.typeParams;
+  ctx.typeParams = new Set(savedTp);
+  for (const tp of sig.typeParameters ?? []) {
+    ctx.typeParams.add(tp.name.text);
+  }
+  try {
+    const paramTypes = sig.parameters.map((param) => {
+      let type;
+      if (param.dotDotDotToken) {
+        const inner = param.type && 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();
+      }
+      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)) {
+    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 (ts.isMethodSignature(member)) {
+    } else if (ts2.isMethodSignature(member)) {
       const name = memberName(member);
       if (name === void 0 || properties[name] !== void 0) continue;
       properties[name] = signatureToFnSig(ctx, member);
@@ -507,38 +988,184 @@ function mapTypeMembers(ctx, members, depth) {
 function mapTypeRef(ctx, node, depth) {
   const name = typeNameString(node.typeName);
   const args = node.typeArguments ?? [];
+  if (ctx.typeParams.has(name) && args.length === 0) {
+    return typeVarAbs(name);
+  }
   if ((name === "Array" || name === "ReadonlyArray") && args.length >= 1) {
     return absArr(mapType(ctx, args[0], depth));
   }
+  if ((name === "List" || name === "ArrayLike" || name === "Collection" || name === "Many" || name === "NumericDictionary" || name === "Dictionary") && args.length >= 1) {
+    return absArr(mapType(ctx, args[0], depth));
+  }
   if (name === "Promise" && args.length >= 1) {
     return absPromise(mapType(ctx, args[0], depth));
   }
+  if ((name === "Map" || name === "ReadonlyMap" || name === "WeakMap") && args.length >= 2) {
+    return absMapType(name, mapType(ctx, args[0], depth), mapType(ctx, args[1], depth));
+  }
+  if ((name === "Set" || name === "ReadonlySet" || name === "WeakSet") && args.length >= 1) {
+    return absSetType(name, mapType(ctx, args[0], depth));
+  }
   if (name === "Record") {
     return absObj({});
   }
   if (ctx.interfaces.has(name) || ctx.qualifiedInterfaces.has(name)) {
-    return instanceFor(ctx, name);
+    return instanceFor(ctx, name, args.map((a) => mapType(ctx, a, depth)));
   }
-  const alias = ctx.aliases.get(name) ?? ctx.qualifiedAliases.get(name);
+  const aliases = ctx.aliases.get(name) ?? ctx.qualifiedAliases.get(name) ?? [];
+  const alias = aliases[0];
   if (alias) return mapType(ctx, alias.type, depth + 1);
   return absUnknown();
 }
+function collectInferNames(node, out = /* @__PURE__ */ new Set()) {
+  const visit = (n) => {
+    if (!n) return;
+    if (ts2.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 (ts2.isInferTypeNode(pattern)) {
+    const name = pattern.typeParameter.name.text;
+    if (!inferMap.has(name)) inferMap.set(name, actual);
+    return "true";
+  }
+  if (ts2.isArrayTypeNode(pattern) && actual.shape.k === "arr") {
+    return matchExtendsInfer(pattern.elementType, actual.shape.element, inferMap, depth + 1);
+  }
+  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);
+    }
+    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";
+}
+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 (ts2.isArrayTypeNode(ext)) {
+    return { fromVar, via: "arr", inferVar };
+  }
+  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 };
+    }
+  }
+  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)) {
+  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 = ts.isNamedTupleMember(element) ? element.type : element;
+      const inner = ts2.isNamedTupleMember(element) ? element.type : element;
       return absArr(mapType(ctx, inner, depth));
     }
     return absUnknown();
   }
-  if (ts.isUnionTypeNode(node)) {
-    return absUnion(node.types.map((t) => mapType(ctx, t, depth)));
+  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);
   }
-  if (ts.isIntersectionTypeNode(node)) {
+  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 = {};
@@ -552,20 +1179,21 @@ function mapType(ctx, node, depth) {
     }
     return members[0] ?? absUnknown();
   }
-  if (ts.isLiteralTypeNode(node)) {
+  if (ts2.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 (ts.isPrefixUnaryExpression(lit) && lit.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(lit.operand)) {
+    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));
     }
     return absUnknown();
   }
-  if (ts.isFunctionTypeNode(node)) return signatureToFnSig(ctx, node);
-  if (ts.isTypeLiteralNode(node)) {
-    const ctor = node.members.find(ts.isConstructSignatureDeclaration);
+  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) {
@@ -577,30 +1205,36 @@ function mapType(ctx, node, depth) {
     }
     return absObj(mapTypeMembers(ctx, node.members, depth));
   }
-  if (ts.isTypeOperatorNode(node)) {
-    return node.operator === ts.SyntaxKind.ReadonlyKeyword ? mapType(ctx, node.type, depth) : absUnknown();
+  if (ts2.isTypeOperatorNode(node)) {
+    return node.operator === ts2.SyntaxKind.ReadonlyKeyword ? mapType(ctx, node.type, depth) : absUnknown();
+  }
+  if (ts2.isConditionalTypeNode(node)) {
+    return mapConditionalType(ctx, node, depth);
+  }
+  if (ts2.isInferTypeNode(node)) {
+    return typeVarAbs(node.typeParameter.name.text);
   }
   switch (node.kind) {
-    case ts.SyntaxKind.StringKeyword:
+    case ts2.SyntaxKind.StringKeyword:
       return absPrim("string");
-    case ts.SyntaxKind.NumberKeyword:
+    case ts2.SyntaxKind.NumberKeyword:
       return absPrim("number");
-    case ts.SyntaxKind.BooleanKeyword:
+    case ts2.SyntaxKind.BooleanKeyword:
       return absPrim("boolean");
-    case ts.SyntaxKind.BigIntKeyword:
+    case ts2.SyntaxKind.BigIntKeyword:
       return absPrim("bigint");
-    case ts.SyntaxKind.SymbolKeyword:
+    case ts2.SyntaxKind.SymbolKeyword:
       return absPrim("symbol");
-    case ts.SyntaxKind.AnyKeyword:
-    case ts.SyntaxKind.UnknownKeyword:
-    case ts.SyntaxKind.ObjectKeyword:
+    case ts2.SyntaxKind.AnyKeyword:
+    case ts2.SyntaxKind.UnknownKeyword:
+    case ts2.SyntaxKind.ObjectKeyword:
       return absUnknown();
-    case ts.SyntaxKind.VoidKeyword:
-    case ts.SyntaxKind.UndefinedKeyword:
+    case ts2.SyntaxKind.VoidKeyword:
+    case ts2.SyntaxKind.UndefinedKeyword:
       return absUndefLit();
-    case ts.SyntaxKind.NeverKeyword:
+    case ts2.SyntaxKind.NeverKeyword:
       return absNever();
-    case ts.SyntaxKind.NullKeyword:
+    case ts2.SyntaxKind.NullKeyword:
       return absNullLit();
     default:
       return absUnknown();
@@ -685,6 +1319,9 @@ function emitAbs(a, expanding) {
   }
 }
 export {
+  dtsPathToContractDraft,
+  dtsToContractDraft,
   emitEnvModule,
+  formatDtsContractDraft,
   harvestDts
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/harvester",
-  "version": "0.2.6",
+  "version": "0.2.8-beta.0",
   "engines": {
     "node": ">=20"
   },
@@ -29,8 +29,8 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "typescript": "^5.8.0",
-    "@nudojs/core": "2.0.1"
+    "typescript": "^5.9.3",
+    "@nudojs/core": "3.0.0-beta.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"