@nudojs/harvester 0.4.2 → 0.4.3

package/dist/index.js

@@ -9,12 +9,16 @@ import {
   joinAbs,
   relationFn,
   getFnImpl,
-  substAbs
+  substAbs,
+  formatShape,
+  absShapeKey,
+  termToString
 } from "@nudojs/core";
 import { absLit } from "@nudojs/core/internal";
 var MAX_ALIAS_DEPTH = 8;
 function scopeKey(scope) {
-  return scope.moduleName ?? "\0global";
+  const base = scope.moduleName ?? "\0global";
+  return scope.nsRec && scope.ns.length > 0 ? `${base}\0ns:${scope.ns.join(".")}` : base;
 }
 function absExact(shape) {
   return makeAbs(shape, void 0, void 0, "exact");
@@ -115,10 +119,14 @@ function harvestDts(files, opts) {
     typeParams: /* @__PURE__ */ new Set(),
     moduleAliases: [],
     importEquals: /* @__PURE__ */ new Map(),
+    exportEquals: /* @__PURE__ */ new Map(),
     declaredModules: /* @__PURE__ */ new Set(),
     pending: [],
     symbols: 0,
-    skipped: 0
+    skipped: 0,
+    degraded: 0,
+    degradedMark: 0,
+    anonDefaultClass: 0
   };
   let parsed = 0;
   for (const file of files) {
@@ -143,10 +151,16 @@ function harvestDts(files, opts) {
     parsed++;
   }
   materialize(ctx);
+  const stats = {
+    files: parsed,
+    symbols: ctx.symbols,
+    skipped: ctx.skipped
+  };
+  if (ctx.degraded > 0) stats.degraded = ctx.degraded;
   return {
     globals: ctx.globals,
     modules: ctx.modules,
-    stats: { files: parsed, symbols: ctx.symbols, skipped: ctx.skipped }
+    stats
   };
 }
 function emitEnvModule(env, pkgName) {
@@ -173,7 +187,8 @@ function emitEnvModule(env, pkgName) {
   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";'
+    // 族 27 Bug 811：泛型 α 的 var term 要落盘 ⇒ 生成代码需要 `termVar`。
+    'import { num, str, bool, never as absNever, unknown as absUnknown, numLit, strLit, boolLit, objOf, relationFn, abs as makeAbs, v as termVar } from "@nudojs/core";'
   );
   lines.push("");
   lines.push("export function defineEnv() {");
@@ -199,11 +214,23 @@ function emitEnvModule(env, pkgName) {
   lines.push("");
   return lines.join("\n");
 }
+function nullDict() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function toNullDict(src) {
+  if (Object.getPrototypeOf(src) === null) return src;
+  const out = nullDict();
+  for (const key of Object.keys(src)) out[key] = src[key];
+  return out;
+}
 function recordFor(ctx, scope) {
+  ctx.globals = toNullDict(ctx.globals);
+  ctx.modules = toNullDict(ctx.modules);
+  if (scope.nsRec) return scope.nsRec;
   if (scope.moduleName === void 0) return ctx.globals;
-  let rec = ctx.modules[scope.moduleName];
+  let rec = Object.hasOwn(ctx.modules, scope.moduleName) ? ctx.modules[scope.moduleName] : void 0;
   if (!rec) {
-    rec = {};
+    rec = nullDict();
     ctx.modules[scope.moduleName] = rec;
   }
   return rec;
@@ -213,6 +240,10 @@ function collectStatements(ctx, statements, scope) {
     collectStatement(ctx, stmt, scope);
   }
 }
+function isDefaultExportDecl(node) {
+  const flags = ts.getCombinedModifierFlags(node);
+  return (flags & ts.ModifierFlags.Default) !== 0;
+}
 function collectStatement(ctx, stmt, scope) {
   if (ts.isModuleDeclaration(stmt)) {
     const body = stmt.body;
@@ -226,22 +257,36 @@ function collectStatement(ctx, stmt, scope) {
     } else if (stmt.name.text === "global") {
       collectStatements(ctx, body.statements, { moduleName: void 0, ns: [] });
     } else {
-      collectStatements(ctx, body.statements, { moduleName: scope.moduleName, ns: [...scope.ns, stmt.name.text] });
+      const nsName = stmt.name.text;
+      const nsRec = nullDict();
+      collectStatements(ctx, body.statements, {
+        moduleName: scope.moduleName,
+        ns: [...scope.ns, nsName],
+        nsRec
+      });
+      ctx.pending.push({ t: "ns", scope, name: nsName, rec: nsRec });
+      ctx.symbols++;
     }
     return;
   }
   if (ts.isFunctionDeclaration(stmt)) {
     if (!stmt.name) {
+      if (isDefaultExportDecl(stmt)) {
+        ctx.pending.push({ t: "fn", scope, name: "default", decls: [stmt] });
+        ctx.symbols++;
+        return;
+      }
       ctx.skipped++;
       return;
     }
     const name = stmt.name.text;
-    const existing = ctx.pending.find((p) => p.t === "fn" && p.name === name && scopeKey(p.scope) === scopeKey(scope));
+    const exportName = isDefaultExportDecl(stmt) ? "default" : name;
+    const existing = ctx.pending.find((p) => p.t === "fn" && p.name === exportName && scopeKey(p.scope) === scopeKey(scope));
     if (existing && existing.t === "fn") {
       existing.decls.push(stmt);
       return;
     }
-    ctx.pending.push({ t: "fn", scope, name, decls: [stmt] });
+    ctx.pending.push({ t: "fn", scope, name: exportName, decls: [stmt] });
     ctx.symbols++;
     return;
   }
@@ -279,13 +324,24 @@ function collectStatement(ctx, stmt, scope) {
   }
   if (ts.isClassDeclaration(stmt)) {
     if (!stmt.name) {
-      ctx.skipped++;
+      if (isDefaultExportDecl(stmt)) {
+        const synth = `__nudo_default_class_${ctx.anonDefaultClass++}`;
+        registerTypeDecl(ctx, scope, synth, stmt);
+        if (!ctx.classes.has(synth)) ctx.classes.set(synth, stmt);
+        ctx.pending.push({ t: "value", scope, name: "default", lookup: synth });
+      } else {
+        ctx.skipped++;
+      }
       return;
     }
     registerTypeDecl(ctx, scope, stmt.name.text, stmt);
     if (!ctx.classes.has(stmt.name.text)) ctx.classes.set(stmt.name.text, stmt);
-    ctx.pending.push({ t: "value", scope, name: stmt.name.text });
-    ctx.symbols++;
+    if (isDefaultExportDecl(stmt)) {
+      ctx.pending.push({ t: "value", scope, name: "default", lookup: stmt.name.text });
+    } else {
+      ctx.pending.push({ t: "value", scope, name: stmt.name.text });
+      ctx.symbols++;
+    }
     return;
   }
   if (ts.isEnumDeclaration(stmt)) {
@@ -327,16 +383,15 @@ function collectStatement(ctx, stmt, scope) {
       return;
     }
     if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+      const clauseTypeOnly = stmt.isTypeOnly === true;
       for (const el of stmt.exportClause.elements) {
         const localName = (el.propertyName ?? el.name).text;
         const exportedName = el.name.text;
-        const isValue = ctx.classes.has(localName) || !el.isTypeOnly && (ctx.interfaces.has(localName) || ctx.qualifiedInterfaces.has(localName));
-        if (isValue) {
-          ctx.pending.push({ t: "value", scope, name: exportedName, lookup: localName });
-          ctx.symbols++;
-        } else {
+        if (clauseTypeOnly || el.isTypeOnly) {
           ctx.skipped++;
+          continue;
         }
+        ctx.pending.push({ t: "value", scope, name: exportedName, lookup: localName });
       }
       return;
     }
@@ -344,13 +399,20 @@ function collectStatement(ctx, stmt, scope) {
     return;
   }
   if (ts.isExportAssignment(stmt)) {
-    if (stmt.expression && ts.isIdentifier(stmt.expression) && scope.moduleName !== void 0) {
+    if (stmt.isExportEquals && 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;
       }
     }
+    if (stmt.expression && ts.isIdentifier(stmt.expression)) {
+      if (stmt.isExportEquals && scope.moduleName !== void 0) {
+        ctx.exportEquals.set(scope.moduleName, stmt.expression.text);
+      }
+      ctx.pending.push({ t: "value", scope, name: "default", lookup: stmt.expression.text });
+      return;
+    }
     ctx.skipped++;
     return;
   }
@@ -366,58 +428,198 @@ function registerTypeDecl(ctx, scope, name, 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) {
+function namespaceChainOf(decl) {
+  const cached = nsChainCache.get(decl);
+  if (cached) return cached;
+  const chain = [];
+  let node = decl.parent;
+  while (node) {
+    if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name) && node.name.text !== "global") {
+      chain.unshift(node.name.text);
+    }
+    node = node.parent;
+  }
+  nsChainCache.set(decl, chain);
+  return chain;
+}
+var nsChainCache = /* @__PURE__ */ new WeakMap();
+function inAmbientModuleBlock(decl) {
+  let node = decl.parent;
+  while (node) {
+    if (ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name)) return true;
+    node = node.parent;
+  }
+  return false;
+}
+function heritageBaseName(expr) {
+  const text = (node) => {
+    if (ts.isIdentifier(node)) return node.text;
+    if (ts.isPropertyAccessExpression(node)) {
+      const left = text(node.expression);
+      if (left === void 0) return void 0;
+      return `${left}.${node.name.text}`;
+    }
+    return void 0;
+  };
+  return text(expr.expression);
+}
+function computedMemberName(name) {
+  if (!name || !ts.isComputedPropertyName(name)) return void 0;
+  const expr = name.expression;
+  if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "Symbol") {
+    if (expr.name.text === "iterator") return "@@iterator";
+    if (expr.name.text === "asyncIterator") return "@@asyncIterator";
+    return void 0;
+  }
+  if (ts.isStringLiteral(expr)) return expr.text;
+  return void 0;
+}
+function resolveIfaceDecls(ctx, name, refNs) {
+  const short = name.includes(".") ? name.split(".").pop() : name;
+  const qualified = name !== short;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (d) => {
+    if (seen.has(d)) return;
+    seen.add(d);
+    out.push(d);
+  };
+  if (qualified) {
+    if (refNs && refNs.length > 0) {
+      for (let i = refNs.length - 1; i >= 0; i--) {
+        const rel = [...refNs.slice(0, i + 1), name].join(".");
+        const decls = ctx.qualifiedInterfaces.get(rel);
+        if (decls && decls.length > 0) {
+          for (const d of decls) add(d);
+          return out;
+        }
+      }
+    }
+    for (const d of ctx.qualifiedInterfaces.get(name) ?? []) add(d);
+    for (const d of ctx.interfaces.get(short) ?? []) {
+      if (namespaceChainOf(d).length === 0 && inAmbientModuleBlock(d)) add(d);
+    }
+    return out;
+  }
+  if (refNs && refNs.length > 0) {
+    for (let i = refNs.length - 1; i >= 0; i--) {
+      const rel = [...refNs.slice(0, i + 1), name].join(".");
+      const decls = ctx.qualifiedInterfaces.get(rel);
+      if (decls && decls.length > 0) {
+        for (const d of decls) add(d);
+        return out;
+      }
+    }
+  }
+  for (const d of ctx.interfaces.get(name) ?? []) {
+    if (namespaceChainOf(d).length === 0) add(d);
+  }
+  return out;
+}
+function interfaceDeclsOf(ctx, typeNode, chain, refNs) {
   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 visited = chain ?? /* @__PURE__ */ new Set();
+  if (visited.has(name)) return [];
+  const nextChain = new Set(visited);
+  nextChain.add(name);
   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);
+  const add = (d) => {
+    if (seen.has(d)) return;
+    seen.add(d);
+    out.push(d);
+  };
+  for (const d of resolveIfaceDecls(ctx, name, refNs)) add(d);
+  for (const d of [...out]) {
+    for (const clause of d.heritageClauses ?? []) {
+      if (clause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+      for (const expr of clause.types) {
+        const baseName = heritageBaseName(expr);
+        if (!baseName) continue;
+        for (const b of interfaceDeclsOf(ctx, baseName, nextChain, namespaceChainOf(d))) add(b);
       }
     }
   }
   return out;
 }
+var realDeclNameCache = /* @__PURE__ */ new WeakMap();
+function realDeclNames(ctx) {
+  const cached = realDeclNameCache.get(ctx);
+  if (cached) return cached;
+  const set = /* @__PURE__ */ new Set();
+  for (const p of ctx.pending) {
+    if (p.t === "iface-expand") continue;
+    set.add(`${scopeKey(p.scope)}::${p.name}`);
+  }
+  realDeclNameCache.set(ctx, set);
+  return set;
+}
+function declNameKey(scope, name) {
+  return `${scopeKey(scope)}::${name}`;
+}
+function optionalPropTypeNode(member) {
+  if (!member.type) return void 0;
+  if (!member.questionToken) return member.type;
+  return ts.factory.createUnionTypeNode([
+    member.type,
+    ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+  ]);
+}
+function optionalMethodTypeNode(member) {
+  const fn = ts.factory.createFunctionTypeNode(
+    member.typeParameters,
+    member.parameters,
+    // 无返回类型标注 ⇒ `any`（`signatureToFnSig` 对缺省返回位的口径是 unknown）
+    member.type ?? ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+  );
+  return ts.factory.createUnionTypeNode([
+    fn,
+    ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+  ]);
+}
 function expandInterfaceAsModuleMembers(ctx, scope, ifaces) {
+  const real = realDeclNames(ctx);
+  const methods = /* @__PURE__ */ new Map();
+  const props = /* @__PURE__ */ new Map();
   for (const iface of ifaces) {
+    if ((iface.typeParameters ?? []).length > 0) continue;
     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++;
+        const list = methods.get(name);
+        if (list) list.push(member);
+        else methods.set(name, [member]);
         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++;
+        props.set(name, member);
       }
     }
   }
+  for (const [name, decls] of methods) {
+    if (props.has(name)) continue;
+    if (real.has(declNameKey(scope, name))) continue;
+    const first = decls[0];
+    if (first.questionToken) {
+      ctx.pending.push({ t: "var", scope, name, typeNode: optionalMethodTypeNode(first) });
+      ctx.symbols++;
+      continue;
+    }
+    ctx.pending.push({ t: "fn", scope, name, decls });
+    ctx.symbols++;
+  }
+  for (const [name, member] of props) {
+    if (real.has(declNameKey(scope, name))) continue;
+    ctx.pending.push({ t: "var", scope, name, typeNode: optionalPropTypeNode(member) });
+    ctx.symbols++;
+  }
 }
 function registerAlias(ctx, scope, stmt) {
   const name = stmt.name.text;
@@ -432,6 +634,126 @@ function registerAlias(ctx, scope, stmt) {
   push(ctx.aliases, name);
   const qualified = [...scope.ns, name].join(".");
   if (qualified !== name) push(ctx.qualifiedAliases, qualified);
+  registerRecursiveAliases(ctx, name);
+}
+var RECURSIVE_ALIAS_MARKER = "__nudoRecursiveAlias";
+var aliasRefsCache = /* @__PURE__ */ new WeakMap();
+var recursiveAliasCache = /* @__PURE__ */ new WeakMap();
+function aliasRefNames(decl) {
+  const hit = aliasRefsCache.get(decl);
+  if (hit) return hit;
+  const out = /* @__PURE__ */ new Set();
+  const visit = (n) => {
+    if (!n) return;
+    if (ts.isTypeReferenceNode(n)) out.add(typeNameString(n.typeName));
+    n.forEachChild(visit);
+  };
+  visit(decl.type);
+  aliasRefsCache.set(decl, out);
+  return out;
+}
+function aliasRefsOf(ctx, name) {
+  const out = /* @__PURE__ */ new Set();
+  for (const decl of ctx.aliases.get(name) ?? []) {
+    for (const r of aliasRefNames(decl)) out.add(r);
+  }
+  return out;
+}
+function aliasReachesSelf(ctx, name, aliasNames) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [];
+  for (const r of aliasRefsOf(ctx, name)) if (aliasNames.has(r)) stack.push(r);
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    if (cur === name) return true;
+    if (seen.has(cur)) continue;
+    seen.add(cur);
+    for (const r of aliasRefsOf(ctx, cur)) if (aliasNames.has(r)) stack.push(r);
+  }
+  return false;
+}
+function registerRecursiveAliases(ctx, newName) {
+  const aliasNames = new Set(ctx.aliases.keys());
+  const known = recursiveAliasCache.get(ctx) ?? /* @__PURE__ */ new Set();
+  const found = [];
+  if (!known.has(newName) && aliasReachesSelf(ctx, newName, aliasNames)) {
+    found.push(newName);
+  }
+  for (const name of aliasNames) {
+    if (name === newName || known.has(name)) continue;
+    if (!aliasRefsOf(ctx, name).has(newName)) continue;
+    if (aliasReachesSelf(ctx, name, aliasNames)) found.push(name);
+  }
+  for (const name of found) {
+    known.add(name);
+    ensureRecursiveAliasInterface(ctx, name);
+  }
+  recursiveAliasCache.set(ctx, known);
+}
+function isRecursiveAliasDecl(decl) {
+  return decl[RECURSIVE_ALIAS_MARKER] === true;
+}
+function ensureRecursiveAliasInterface(ctx, name) {
+  const decl = ctx.aliases.get(name)?.[0];
+  if (!decl) return;
+  const existing = ctx.interfaces.get(name) ?? [];
+  if (existing.some((d) => isRecursiveAliasDecl(d))) return;
+  const members = ts.isTypeLiteralNode(decl.type) ? [...decl.type.members] : [];
+  const iface = ts.factory.createInterfaceDeclaration(
+    void 0,
+    ts.factory.createIdentifier(name),
+    decl.typeParameters,
+    void 0,
+    ts.factory.createNodeArray(members)
+  );
+  iface[RECURSIVE_ALIAS_MARKER] = true;
+  ctx.interfaces.set(name, [...existing, iface]);
+}
+function classValueAbs(ctx, cls, key) {
+  const ctor = cls.members.find(ts.isConstructorDeclaration);
+  const params = [];
+  if (ctor) {
+    for (const param of ctor.parameters) {
+      if (isThisParameter(param)) continue;
+      let type = param.type ? mapType(ctx, param.type, 0) : absUnknown();
+      if (param.questionToken) type = absUnion([type, absUndefLit()]);
+      params.push(type);
+    }
+  }
+  return absCtorSig(params, instanceFor(ctx, key));
+}
+function resolveLocalValue(ctx, scope, key) {
+  const rec = recordFor(ctx, scope);
+  if (Object.hasOwn(rec, key)) return rec[key];
+  if (scope.moduleName !== void 0 && Object.hasOwn(ctx.globals, key)) return ctx.globals[key];
+  const cls = ctx.classes.get(key);
+  if (cls) return classValueAbs(ctx, cls, key);
+  if (ctx.interfaces.has(key) || ctx.qualifiedInterfaces.has(key)) return instanceFor(ctx, key);
+  return void 0;
+}
+function mergeOverloadParams(sigs) {
+  const first = sigs[0];
+  if (!first || first.shape.k !== "fn") return void 0;
+  const base = first.shape.paramTypes ?? [];
+  if (base.length === 0) return void 0;
+  const perPos = base.map(() => []);
+  for (const s of sigs) {
+    if (s.shape.k !== "fn") return void 0;
+    const pts = s.shape.paramTypes ?? [];
+    if (pts.length !== base.length) return void 0;
+    for (let i = 0; i < pts.length; i++) {
+      const t = pts[i];
+      if (hasTypeVar(t)) return void 0;
+      perPos[i].push(t);
+    }
+  }
+  return perPos.map((ts4) => ts4.length === 1 ? ts4[0] : absUnion(ts4));
+}
+function mergeModuleRecords(base, over) {
+  const merged = nullDict();
+  for (const k of Object.keys(base)) merged[k] = base[k];
+  for (const k of Object.keys(over)) merged[k] = over[k];
+  return merged;
 }
 function materialize(ctx) {
   const expanded = [];
@@ -452,27 +774,83 @@ function materialize(ctx) {
     }
   }
   ctx.pending = expanded;
+  const nsSlots = [];
+  const nsSlotsByName = /* @__PURE__ */ new Map();
   for (const p of ctx.pending) {
     if (p.t === "iface-expand") continue;
     const rec = recordFor(ctx, p.scope);
+    if (p.t === "ns") {
+      const names = Object.keys(p.rec);
+      if (names.length === 0) {
+        continue;
+      }
+      const slots = nullDict();
+      for (const n of names) slots[n] = { value: p.rec[n] };
+      if (p.scope.moduleName !== void 0 && ctx.exportEquals.get(p.scope.moduleName) === p.name) {
+        const flat = recordFor(ctx, p.scope);
+        for (const [k, v] of Object.entries(p.rec)) {
+          if (Object.hasOwn(flat, k)) continue;
+          flat[k] = v;
+        }
+        nsSlots.push({ rec: p.rec, slots, flat });
+        continue;
+      }
+      const existing = rec[p.name];
+      if (existing === void 0) {
+        rec[p.name] = objOf(slots);
+        nsSlotsByName.set(`${scopeKey(p.scope)}\0${p.name}`, slots);
+      } else if (existing.shape.k === "fn") {
+        existing.shape.slots = slots;
+        nsSlotsByName.set(`${scopeKey(p.scope)}\0${p.name}`, slots);
+      } else {
+        ctx.skipped++;
+        continue;
+      }
+      nsSlots.push({ rec: p.rec, slots });
+      continue;
+    }
     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 fnValue = () => {
+        const sigs = p.decls.map((d) => signatureToFnSig(ctx, d));
+        const value2 = sigs[0];
+        const shape0 = value2.shape.k === "fn" ? value2.shape : void 0;
+        if (shape0 && sigs.length > 1) {
+          const mergedParams = mergeOverloadParams(sigs);
+          if (mergedParams) {
+            shape0.paramTypes = mergedParams;
+            const rel0 = getFnImpl(value2)?.relation;
+            if (rel0) rel0.paramTypes = mergedParams;
+          }
+          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(value2)?.relation;
+          if (rel) rel.returnType = mergedRet;
         }
-        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;
+        return value2;
+      };
+      const existing = rec[p.name];
+      if (existing !== void 0) {
+        const nsStatic = nsSlotsByName.get(`${scopeKey(p.scope)}${p.name}`);
+        if (nsStatic && existing.shape.k === "obj") {
+          const value2 = fnValue();
+          value2.shape.slots = nsStatic;
+          rec[p.name] = value2;
+        }
+        continue;
+      }
+      const markBefore = ctx.degradedMark;
+      const value = fnValue();
+      if (ctx.degradedMark > markBefore) {
+        ctx.degraded++;
+        ctx.degradedMark = markBefore;
       }
       rec[p.name] = value;
       continue;
@@ -480,30 +858,32 @@ function materialize(ctx) {
     if (rec[p.name] !== void 0) continue;
     switch (p.t) {
       case "var": {
+        const markBefore = ctx.degradedMark;
         const mapped = p.typeNode ? mapType(ctx, p.typeNode, 0) : absUnknown();
-        if (isPlainUnknown(mapped)) {
-          ctx.skipped++;
-          break;
+        if (ctx.degradedMark > markBefore) {
+          ctx.degraded++;
+          ctx.degradedMark = markBefore;
         }
         rec[p.name] = mapped;
         break;
       }
       case "value": {
-        const cls = ctx.classes.get(p.lookup ?? p.name);
+        const key = p.lookup ?? p.name;
+        const cls = ctx.classes.get(key);
         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);
-            }
+          const markBefore = ctx.degradedMark;
+          rec[p.name] = classValueAbs(ctx, cls, key);
+          if (ctx.degradedMark > markBefore) {
+            ctx.degraded++;
+            ctx.degradedMark = markBefore;
           }
-          rec[p.name] = absFnSig(params, instanceFor(ctx, p.lookup ?? p.name));
-        } else {
-          rec[p.name] = instanceFor(ctx, p.lookup ?? p.name);
+          if (p.lookup !== void 0) ctx.symbols++;
+          break;
         }
+        if (p.lookup !== void 0) {
+          break;
+        }
+        rec[p.name] = instanceFor(ctx, key);
         break;
       }
       case "enum":
@@ -511,14 +891,69 @@ function materialize(ctx) {
         break;
     }
   }
+  for (const p of ctx.pending) {
+    if (p.t !== "value" || p.lookup === void 0) continue;
+    const rec = recordFor(ctx, p.scope);
+    if (Object.hasOwn(rec, p.name)) continue;
+    const resolved = resolveLocalValue(ctx, p.scope, p.lookup);
+    if (resolved === void 0) {
+      ctx.skipped++;
+      continue;
+    }
+    rec[p.name] = resolved;
+    ctx.symbols++;
+  }
+  for (const { rec: nsRec, slots, flat } of nsSlots) {
+    for (const [k, v] of Object.entries(nsRec)) {
+      if (Object.hasOwn(slots, k)) continue;
+      slots[k] = { value: v };
+      if (flat && !Object.hasOwn(flat, k)) flat[k] = v;
+    }
+  }
+  const aliasTargets = /* @__PURE__ */ new Map();
   for (const [alias, target] of ctx.moduleAliases) {
-    if (ctx.modules[target] && !ctx.modules[alias]) {
-      ctx.modules[alias] = ctx.modules[target];
+    const list = aliasTargets.get(alias);
+    if (list) {
+      if (!list.includes(target)) list.push(target);
+    } else {
+      aliasTargets.set(alias, [target]);
+    }
+  }
+  const aliasResolved = /* @__PURE__ */ new Map();
+  const aliasResolving = /* @__PURE__ */ new Set();
+  const resolveModule = (name, depth) => {
+    const cached = aliasResolved.get(name);
+    if (cached) return cached;
+    if (depth > MAX_ALIAS_DEPTH || aliasResolving.has(name)) return void 0;
+    aliasResolving.add(name);
+    const own = ctx.modules[name];
+    const targets = aliasTargets.get(name);
+    let merged;
+    if (targets) {
+      for (const target of targets) {
+        const t = resolveModule(target, depth + 1);
+        if (!t) continue;
+        merged = merged ? mergeModuleRecords(merged, t) : t;
+      }
     }
+    aliasResolving.delete(name);
+    if (!merged) return own;
+    const out = own && Object.keys(own).length > 0 ? mergeModuleRecords(merged, own) : merged;
+    aliasResolved.set(name, out);
+    return out;
+  };
+  for (const name of aliasTargets.keys()) {
+    const out = resolveModule(name, 0);
+    if (out) ctx.modules[name] = out;
   }
 }
 function typeNameString(name) {
   if (ts.isIdentifier(name)) return name.text;
+  if (ts.isPropertyAccessExpression(name)) {
+    const left = name.expression;
+    if (!ts.isIdentifier(left) && !ts.isPropertyAccessExpression(left)) return name.name.text;
+    return `${typeNameString(left)}.${name.name.text}`;
+  }
   return `${typeNameString(name.left)}.${name.right.text}`;
 }
 function memberName(node) {
@@ -527,82 +962,220 @@ function memberName(node) {
   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);
+function absBrandOpen(name) {
+  return absExact({ k: "brand", name, shape: absUnknown() });
+}
+function absFingerprint(a) {
+  const key = absShapeKey(a);
+  const term = a.term && a.term.op !== "lit" ? termToString(a.term) : "";
+  return term ? `${key}#${term}` : key;
+}
+function memberDict() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function effectiveTypeArgs(ctx, decls, typeArgs) {
+  const tps = decls[0]?.typeParameters ?? [];
+  if (tps.length === 0) return [];
+  const out = [];
+  for (let i = 0; i < tps.length; i++) {
+    const tp = tps[i];
+    const explicit = typeArgs?.[i];
+    if (explicit !== void 0) {
+      out.push(explicit);
+      continue;
+    }
+    if (tp.default) {
+      out.push(mapType(ctx, tp.default, 0));
+      continue;
+    }
+    if (tp.constraint) {
+      const c = mapType(ctx, tp.constraint, 0);
+      out.push(isPlainUnknown(c) ? absUnknown() : c);
+      continue;
+    }
+    out.push(absUnknown());
+  }
+  return out;
+}
+function mergeOverloadSigs(sigs) {
+  const first = sigs[0];
+  if (!first) return absUnknown();
+  if (sigs.length === 1) return first;
+  if (first.shape.k !== "fn") return first;
+  const params = mergeOverloadParams(sigs) ?? first.shape.paramTypes ?? [];
+  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();
+  const rel0 = getFnImpl(first)?.relation;
+  const extra = rel0 ? {
+    ...rel0.inferFrom ? { inferFrom: rel0.inferFrom } : {},
+    ...rel0.condFallback !== void 0 ? { condFallback: rel0.condFallback } : {}
+  } : void 0;
+  return absFnSig(params, mergedRet, extra);
+}
+function typeParamBindings(decls, args) {
+  const map = /* @__PURE__ */ new Map();
+  const tps = decls[0]?.typeParameters ?? [];
+  tps.forEach((tp, i) => {
+    const arg = args[i];
+    if (arg) map.set(tp.name.text, arg);
+  });
+  return map;
+}
+function collectIfaceEntries(ctx, decls, args, chain, refNs, outerBindings) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of decls) {
+    if (seen.has(d)) continue;
+    seen.add(d);
+    out.push({ decl: d, typeArgs: [...args], bindings: typeParamBindings([d], args) });
+  }
+  for (const d of decls) {
+    const dNs = namespaceChainOf(d);
+    for (const clause of d.heritageClauses ?? []) {
+      if (clause.token !== ts.SyntaxKind.ExtendsKeyword) continue;
+      for (const expr of clause.types) {
+        const baseName = heritageBaseName(expr);
+        if (!baseName || chain.has(baseName)) continue;
+        const baseDecls = resolveIfaceDecls(ctx, baseName, dNs);
+        if (baseDecls.length === 0) continue;
+        const explicit = expr.typeArguments ?? [];
+        const baseArgs = explicit.length > 0 ? explicit.map((a) => mapType(ctx, a, 0, outerBindings)) : effectiveTypeArgs(ctx, baseDecls, void 0);
+        const nextChain = new Set(chain);
+        nextChain.add(baseName);
+        out.push(
+          ...collectIfaceEntries(
+            ctx,
+            baseDecls,
+            baseArgs,
+            nextChain,
+            dNs,
+            typeParamBindings(baseDecls, baseArgs)
+          )
+        );
+      }
+    }
+  }
+  return out;
+}
+function instanceFor(ctx, key, typeArgs, refNs) {
+  const decls = resolveIfaceDecls(ctx, key, refNs);
   const decl = decls[0];
   if (!decl) return absUnknown();
-  if (ctx.expanding.has(key)) {
-    return absBrand(decl.name?.text ?? key, {});
+  const nsTag = refNs && refNs.length > 0 ? `ns:${refNs.join(".")}:` : "";
+  const cacheKey = `${nsTag}${key}`;
+  if (ctx.expanding.has(cacheKey)) {
+    return absBrandOpen(decl.name?.text ?? key);
   }
-  ctx.expanding.add(key);
+  ctx.expanding.add(cacheKey);
   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) {
+      for (const tp of d.typeParameters ?? []) ctx.typeParams.add(tp.name.text);
+    }
+    const effective = effectiveTypeArgs(ctx, decls, typeArgs);
+    const argKey = effective.length > 0 ? `${cacheKey}::${effective.map(absFingerprint).join("|")}` : cacheKey;
+    const cached = ctx.instanceCache.get(argKey);
+    if (cached !== void 0) return cached;
+    const entries = collectIfaceEntries(
+      ctx,
+      decls,
+      effective,
+      /* @__PURE__ */ new Set([key]),
+      refNs,
+      typeParamBindings(decls, effective)
+    );
+    for (const entry of entries) {
+      for (const tp of entry.decl.typeParameters ?? []) ctx.typeParams.add(tp.name.text);
+    }
+    const properties = memberDict();
+    const methodSigs = /* @__PURE__ */ new Map();
+    const optionalMethods = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const d = entry.decl;
       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);
+          const name = memberName(member) ?? computedMemberName(member.name);
           if (name === void 0) continue;
-          let type = member.type ? mapType(ctx, member.type, 0) : absUnknown();
+          let type = member.type ? mapType(ctx, member.type, 0, entry.bindings) : absUnknown();
           if (member.questionToken) type = absUnion([type, absUndefLit()]);
           properties[name] = type;
+          methodSigs.delete(name);
+          optionalMethods.delete(name);
         } 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);
+          const name = memberName(member) ?? computedMemberName(member.name);
+          if (name === void 0) continue;
+          if (properties[name] !== void 0) continue;
+          const sig = signatureToFnSig(ctx, member, entry.bindings);
+          const list = methodSigs.get(name);
+          if (list) list.push(sig);
+          else methodSigs.set(name, [sig]);
+          optionalMethods.set(
+            name,
+            (optionalMethods.get(name) ?? true) && member.questionToken !== void 0
+          );
         } else if (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) {
-          const name = memberName(member);
+          const name = memberName(member) ?? computedMemberName(member.name);
           if (name === void 0 || properties[name] !== void 0 || !member.type) continue;
-          properties[name] = mapType(ctx, member.type, 0);
+          properties[name] = mapType(ctx, member.type, 0, entry.bindings);
         }
       }
     }
+    for (const [name, sigs] of methodSigs) {
+      const merged = mergeOverloadSigs(sigs);
+      properties[name] = optionalMethods.get(name) ? absUnion([merged, absUndefLit()]) : merged;
+    }
+    const opaque = isRecursiveAliasDecl(decl) && Object.keys(properties).length === 0;
+    let value = opaque ? absBrandOpen(decl.name?.text ?? key) : absBrand(decl.name?.text ?? key, properties);
+    if (effective.length > 0 && Object.keys(properties).length <= 40) {
+      const map = /* @__PURE__ */ new Map();
+      const tps = decls[0].typeParameters ?? [];
+      tps.forEach((tp, i) => {
+        const arg = effective[i];
+        if (arg) map.set(tp.name.text, arg);
+      });
+      if (map.size > 0) value = substAbs(value, map);
+    }
+    ctx.instanceCache.set(argKey, value);
+    return value;
   } 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.expanding.delete(cacheKey);
   }
-  ctx.instanceCache.set(cacheKey, value);
-  return value;
 }
-function signatureToFnSig(ctx, sig) {
+function isThisParameter(param) {
+  const name = param.name;
+  return ts.isIdentifier(name) && name.text === "this";
+}
+function signatureToFnSig(ctx, sig, bindings) {
   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) => {
+    const paramTypes = sig.parameters.filter((param) => !isThisParameter(param)).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();
+        type = inner ? absArr(mapType(ctx, inner, 0, bindings)) : absUnknown();
       } else {
-        type = param.type ? mapType(ctx, param.type, 0) : absUnknown();
+        type = param.type ? mapType(ctx, param.type, 0, bindings) : absUnknown();
       }
       if (param.questionToken && !param.dotDotDotToken) type = absUnion([type, absUndefLit()]);
       return type;
     });
-    const returnType = sig.type ? mapType(ctx, sig.type, 0) : absUnknown();
+    const returnType = sig.type ? mapType(ctx, sig.type, 0, bindings) : absUnknown();
     const cond = ctx.pendingCond;
     ctx.pendingCond = void 0;
     return absFnSig(paramTypes, returnType, cond ? {
@@ -613,123 +1186,506 @@ function signatureToFnSig(ctx, sig) {
     ctx.typeParams = savedTp;
   }
 }
-function mapTypeMembers(ctx, members, depth) {
+function mapTypeMembers(ctx, members, depth, bindings) {
   const properties = {};
+  let index;
+  const accessorReads = /* @__PURE__ */ new Map();
+  const accessorWrites = /* @__PURE__ */ new Map();
   for (const member of members) {
     if (ts.isPropertySignature(member)) {
-      const name = memberName(member);
+      const name = memberName(member) ?? computedMemberName(member.name);
       if (name === void 0) continue;
-      let type = member.type ? mapType(ctx, member.type, depth) : absUnknown();
+      let type = member.type ? mapType(ctx, member.type, depth, bindings) : absUnknown();
       if (member.questionToken) type = absUnion([type, absUndefLit()]);
       properties[name] = type;
     } else if (ts.isMethodSignature(member)) {
-      const name = memberName(member);
+      const name = memberName(member) ?? computedMemberName(member.name);
       if (name === void 0 || properties[name] !== void 0) continue;
-      properties[name] = signatureToFnSig(ctx, member);
+      const sig = signatureToFnSig(ctx, member);
+      properties[name] = member.questionToken ? absUnion([sig, absUndefLit()]) : sig;
+    } else if (ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) {
+      const name = memberName(member) ?? computedMemberName(member.name);
+      if (name === void 0) continue;
+      if (ts.isGetAccessorDeclaration(member)) {
+        accessorReads.set(
+          name,
+          member.type ? mapType(ctx, member.type, depth, bindings) : absUnknown()
+        );
+      } else {
+        const param = member.parameters[0];
+        accessorWrites.set(
+          name,
+          param?.type ? mapType(ctx, param.type, depth, bindings) : absUnknown()
+        );
+      }
+    } else if (ts.isIndexSignatureDeclaration(member)) {
+      const keyParam = member.parameters[0];
+      const key = keyParam?.type ? mapType(ctx, keyParam.type, depth, bindings) : absPrim("string");
+      const value = member.type ? mapType(ctx, member.type, depth, bindings) : absUnknown();
+      index = { key, value };
+    }
+  }
+  for (const [name, read] of accessorReads) {
+    if (properties[name] === void 0) properties[name] = read;
+  }
+  for (const [name, write] of accessorWrites) {
+    if (properties[name] === void 0) {
+      properties[name] = absUnion([write, absUndefLit()]);
+    }
+  }
+  return { properties, index };
+}
+function stripParens(node) {
+  let n = node;
+  while (ts.isParenthesizedTypeNode(n)) n = n.type;
+  return n;
+}
+function fileSaltOf(fileName) {
+  let h = 2166136261;
+  for (let i = 0; i < fileName.length; i++) {
+    h ^= fileName.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(36);
+}
+function scopeTagOf(scope) {
+  let file = "";
+  try {
+    file = scope.getSourceFile()?.fileName ?? "";
+  } catch {
+    file = "";
+  }
+  return `${fileSaltOf(file)}${scope.pos}`;
+}
+function typeParamVarId(node, name) {
+  const scopes = [];
+  let p = node.parent;
+  while (p) {
+    const tps = p.typeParameters;
+    if (tps) {
+      for (const tp of tps) {
+        if (tp.name.text === name) {
+          scopes.push(p);
+          break;
+        }
+      }
+    }
+    p = p.parent;
+  }
+  if (scopes.length <= 1) return name;
+  return `${name}@${scopeTagOf(scopes[0])}`;
+}
+function lookupTypeParamBinding(bindings, node, name) {
+  if (!bindings) return void 0;
+  const id = typeParamVarId(node, name);
+  return bindings.get(id) ?? bindings.get(`infer:${name}`);
+}
+function absOpenObj(properties, index) {
+  const slots = {};
+  for (const [k, v] of Object.entries(properties)) {
+    slots[k] = { value: v };
+  }
+  return objOf(slots, index ? { index, open: true } : { open: true });
+}
+function slotsOfAbs(a) {
+  const s = a.shape;
+  if (s.k === "obj") {
+    const out = {};
+    for (const [k, slot] of Object.entries(s.slots)) out[k] = slot.value;
+    return out;
+  }
+  if (s.k === "brand") return slotsOfAbs(s.shape);
+  return void 0;
+}
+function sameAbsType(a, b) {
+  if (a === b) return true;
+  return formatShape(a) === formatShape(b);
+}
+function mergeIntersection(members) {
+  const slots = {};
+  let merged = 0;
+  for (const member of members) {
+    const mSlots = slotsOfAbs(member);
+    if (!mSlots) return void 0;
+    merged++;
+    for (const [key, value] of Object.entries(mSlots)) {
+      if (!Object.hasOwn(slots, key)) {
+        slots[key] = value;
+        continue;
+      }
+      const prev = slots[key];
+      if (!sameAbsType(prev, value)) slots[key] = absNever();
+    }
+  }
+  if (merged === 0) return void 0;
+  return absObj(slots);
+}
+function absCtorSig(params, instance, extra) {
+  const a = absFnSig(params, instance, extra);
+  a.shape.ctor = true;
+  return a;
+}
+function takePendingCond(ctx) {
+  const cond = ctx.pendingCond;
+  ctx.pendingCond = void 0;
+  return cond;
+}
+function condExtra(cond) {
+  if (!cond) return void 0;
+  return {
+    inferFrom: { fromVar: cond.fromVar, via: cond.via, inferVar: cond.inferVar },
+    condFallback: cond.fallback
+  };
+}
+function attachFnSlots(fn, properties) {
+  const names = Object.keys(properties);
+  if (names.length === 0) return fn;
+  const slots = {};
+  for (const [k, v] of Object.entries(properties)) slots[k] = { value: v };
+  fn.shape.slots = slots;
+  return fn;
+}
+function keyofNamesOf(ctx, node, depth) {
+  const n = stripParens(node);
+  if (ts.isTypeLiteralNode(n)) {
+    const names = [];
+    for (const member of n.members) {
+      if (ts.isIndexSignatureDeclaration(member)) continue;
+      const name = memberName(member);
+      if (name !== void 0) names.push(name);
+    }
+    return names;
+  }
+  if (ts.isTypeReferenceNode(n)) {
+    const name = typeNameString(n.typeName);
+    if (ctx.interfaces.has(name) || ctx.qualifiedInterfaces.has(name)) {
+      const slots = slotsOfAbs(instanceFor(ctx, name));
+      return slots ? Object.keys(slots) : void 0;
+    }
+    const aliases = ctx.aliases.get(name) ?? ctx.qualifiedAliases.get(name) ?? [];
+    const alias = aliases[0];
+    if (alias) {
+      const slots = slotsOfAbs(mapType(ctx, alias.type, depth + 1));
+      return slots ? Object.keys(slots) : void 0;
+    }
+  }
+  return void 0;
+}
+var BUILTIN_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "Array",
+  "ReadonlyArray",
+  "Promise",
+  "PromiseLike",
+  "Map",
+  "ReadonlyMap",
+  "WeakMap",
+  "Set",
+  "ReadonlySet",
+  "WeakSet",
+  "Record",
+  "Partial",
+  "Readonly",
+  "Required",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "Parameters",
+  "ReturnType",
+  "Awaited",
+  "Iterable",
+  "Iterator",
+  "IterableIterator",
+  "AsyncIterable",
+  "AsyncIterator",
+  "AsyncIterableIterator",
+  "Generator",
+  "AsyncGenerator",
+  "Date",
+  "RegExp",
+  "Error",
+  "JSON",
+  "Object",
+  "Function",
+  "ArrayBuffer",
+  "Uint8Array",
+  "Int8Array",
+  "Uint16Array",
+  "Int16Array",
+  "Uint32Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "ArrayLike",
+  "List",
+  "Collection",
+  "Many",
+  "NumericDictionary",
+  "Dictionary"
+]);
+function typeSideKind(ctx, node, depth) {
+  const n = stripParens(node);
+  if (ts.isTypeOperatorNode(n)) {
+    if (n.operator === ts.SyntaxKind.KeyOfKeyword) {
+      return keyofNamesOf(ctx, n.type, depth) ? "ok" : "degraded";
     }
+    if (n.operator === ts.SyntaxKind.ReadonlyKeyword) return typeSideKind(ctx, n.type, depth);
+    return "degraded";
+  }
+  if (ts.isTypeQueryNode(n)) return "degraded";
+  if (ts.isMappedTypeNode(n)) return "degraded";
+  if (ts.isIndexedAccessTypeNode(n)) return "degraded";
+  if (ts.isImportTypeNode(n)) return "degraded";
+  if (ts.isTemplateLiteralTypeNode(n)) return "degraded";
+  if (ts.isConditionalTypeNode(n)) return "degraded";
+  if (ts.isUnionTypeNode(n)) {
+    for (const t of n.types) {
+      if (typeSideKind(ctx, t, depth) === "degraded") return "degraded";
+    }
+    return "ok";
+  }
+  if (ts.isTypeReferenceNode(n)) {
+    const name = typeNameString(n.typeName);
+    if (ctx.typeParams.has(name)) return "ok";
+    if (ctx.interfaces.has(name) || ctx.qualifiedInterfaces.has(name)) return "ok";
+    if ((ctx.aliases.get(name) ?? ctx.qualifiedAliases.get(name) ?? []).length > 0) return "ok";
+    if (BUILTIN_TYPE_NAMES.has(name)) return "ok";
+    return "degraded";
+  }
+  return "ok";
+}
+function isSignatureReturnPos(node) {
+  let cur = node;
+  let p = cur.parent;
+  while (p && ts.isParenthesizedTypeNode(p)) {
+    cur = p;
+    p = p.parent;
+  }
+  if (!p) return false;
+  switch (p.kind) {
+    case ts.SyntaxKind.FunctionType:
+    case ts.SyntaxKind.ConstructorType:
+      return p.type === cur;
+    case ts.SyntaxKind.FunctionDeclaration:
+    case ts.SyntaxKind.MethodDeclaration:
+    case ts.SyntaxKind.MethodSignature:
+    case ts.SyntaxKind.CallSignature:
+    case ts.SyntaxKind.ConstructSignature:
+      return p.type === cur;
+    default:
+      return false;
   }
-  return properties;
 }
-function mapTypeRef(ctx, node, depth) {
+function mapTypeRef(ctx, node, depth, bindings) {
   const name = typeNameString(node.typeName);
   const args = node.typeArguments ?? [];
   if (ctx.typeParams.has(name) && args.length === 0) {
-    return typeVarAbs(name);
+    const bound = lookupTypeParamBinding(bindings, node, name);
+    if (bound) return bound;
+    return typeVarAbs(typeParamVarId(node, name));
   }
   if ((name === "Array" || name === "ReadonlyArray") && args.length >= 1) {
-    return absArr(mapType(ctx, args[0], depth));
+    return absArr(mapType(ctx, args[0], depth, bindings));
   }
   if ((name === "List" || name === "ArrayLike" || name === "Collection" || name === "Many" || name === "NumericDictionary" || name === "Dictionary") && args.length >= 1) {
-    return absArr(mapType(ctx, args[0], depth));
+    return absArr(mapType(ctx, args[0], depth, bindings));
   }
   if (name === "Promise" && args.length >= 1) {
-    return absPromise(mapType(ctx, args[0], depth));
+    return absPromise(mapType(ctx, args[0], depth, bindings));
   }
   if ((name === "Map" || name === "ReadonlyMap" || name === "WeakMap") && args.length >= 2) {
-    return absMapType(name, mapType(ctx, args[0], depth), mapType(ctx, args[1], depth));
+    return absMapType(
+      name,
+      mapType(ctx, args[0], depth, bindings),
+      mapType(ctx, args[1], depth, bindings)
+    );
   }
   if ((name === "Set" || name === "ReadonlySet" || name === "WeakSet") && args.length >= 1) {
-    return absSetType(name, mapType(ctx, args[0], depth));
+    return absSetType(name, mapType(ctx, args[0], depth, bindings));
   }
   if (name === "Record") {
-    return absObj({});
+    const value = args[1] ? mapType(ctx, args[1], depth, bindings) : absUnknown();
+    const key = args[0] ? mapType(ctx, args[0], depth, bindings) : absPrim("string");
+    return absOpenObj({}, { key, value });
   }
   if (ctx.interfaces.has(name) || ctx.qualifiedInterfaces.has(name)) {
-    return instanceFor(ctx, name, args.map((a) => mapType(ctx, a, depth)));
+    return instanceFor(
+      ctx,
+      name,
+      args.map((a) => mapType(ctx, a, depth, bindings)),
+      namespaceChainOf(node)
+    );
   }
   const aliases = ctx.aliases.get(name) ?? ctx.qualifiedAliases.get(name) ?? [];
   const alias = aliases[0];
-  if (alias) return mapType(ctx, alias.type, depth + 1);
+  if (alias) return mapAliasWithArgs(ctx, alias, args, depth, bindings);
   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;
-    }
+function mapAliasWithArgs(ctx, alias, args, depth, bindings) {
+  const tps = alias.typeParameters ?? [];
+  if (tps.length === 0 || args.length === 0) return mapType(ctx, alias.type, depth + 1);
+  const savedTp = ctx.typeParams;
+  ctx.typeParams = new Set(savedTp);
+  for (const tp of tps) ctx.typeParams.add(tp.name.text);
+  try {
+    const body = mapType(ctx, alias.type, depth + 1);
+    const map = /* @__PURE__ */ new Map();
+    tps.forEach((tp, i) => {
+      const arg = args[i];
+      if (!arg) return;
+      map.set(
+        typeParamVarId(alias.type, tp.name.text),
+        mapType(ctx, arg, depth + 1, bindings)
+      );
+    });
+    return map.size > 0 ? substAbs(body, map) : body;
+  } finally {
+    ctx.typeParams = savedTp;
+  }
+}
+function collectInferNames(node, out = /* @__PURE__ */ new Set()) {
+  const visit = (n) => {
+    if (!n) return;
+    if (ts.isParenthesizedTypeNode(n)) {
+      visit(n.type);
+      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) {
+function absExtends(check, ext, depth = 0) {
+  if (depth > 6) return "unknown";
   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";
+  const cs = check.shape;
+  const es = ext.shape;
+  const cIsLit = check.term?.op === "lit";
+  const eIsLit = ext.term?.op === "lit";
+  const cLit = check.term && check.term.op === "lit" ? check.term.value : void 0;
+  const eLit = ext.term && ext.term.op === "lit" ? ext.term.value : void 0;
+  if (cIsLit && eIsLit) {
+    return cLit === eLit && typeof cLit === typeof eLit ? "true" : "false";
+  }
+  if (cIsLit) {
+    if (eIsLit && (eLit === null || eLit === void 0)) return "false";
+    if (es.k === "prim") {
+      if (cLit === null) return "false";
+      return typeof cLit === es.type ? "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";
+    if (es.k === "sum") {
+      const flags = es.members.map((m) => absExtends(check, m, depth + 1));
+      if (flags.some((f) => f === "true")) return "true";
+      if (flags.every((f) => f === "false")) return "false";
+      return "unknown";
     }
+    if (es.k === "unknown") return "true";
+    if (es.k === "never") return "false";
+    if (es.k === "any") return "unknown";
+    if (es.k === "arr" || es.k === "tuple") 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 (eIsLit) {
+    return "false";
+  }
+  if (es.k === "any") return "unknown";
+  if (es.k === "unknown") return "true";
+  if (cs.k === "any") return "unknown";
+  if (cs.k === "unknown") return "false";
+  if (cs.k === "never") return "true";
+  if (es.k === "never") return "false";
   if (es.k === "prim" && cs.k === "prim") {
     return cs.type === es.type ? "true" : "false";
   }
+  if ((es.k === "arr" || es.k === "tuple") && (cs.k === "prim" || cs.k === "obj" || cs.k === "fn" || cs.k === "brand")) {
+    return "false";
+  }
   if (es.k === "sum") {
-    const flags = es.members.map((m) => absExtends(check, m));
+    const flags = es.members.map((m) => absExtends(check, m, depth + 1));
     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));
+    const flags = cs.members.map((m) => absExtends(m, ext, depth + 1));
     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);
+    return absExtends(cs.element, es.element, depth + 1);
+  }
+  if (cs.k === "tuple" && es.k === "arr") {
+    const flags = cs.elements.map((el) => absExtends(el, es.element, depth + 1));
+    return flags.some((f) => f === "false") ? "false" : "true";
+  }
+  if (cs.k === "tuple" && es.k === "tuple") {
+    if (cs.elements.length !== es.elements.length) return "unknown";
+    const flags = cs.elements.map((el, i) => absExtends(el, es.elements[i], depth + 1));
+    if (flags.some((f) => f === "false")) return "false";
+    if (flags.every((f) => f === "true")) return "true";
+    return "unknown";
   }
   if (cs.k === "eff" && es.k === "eff" && cs.eff === es.eff) {
-    return absExtends(cs.inner, es.inner);
+    return absExtends(cs.inner, es.inner, depth + 1);
   }
   if (cs.k === "brand" && es.k === "brand") {
-    return cs.name === es.name ? "true" : "false";
+    if (cs.name === es.name) return "true";
+    return structuralExtends(check, ext, depth);
+  }
+  if (cs.k === "obj" && es.k === "obj" || cs.k === "brand" && es.k === "obj" || cs.k === "obj" && es.k === "brand") {
+    return structuralExtends(check, ext, depth);
+  }
+  if (cs.k === "fn" && es.k === "fn") {
+    const a = cs.returnType;
+    const b = es.returnType;
+    if (!a || !b) return "unknown";
+    return absExtends(a, b, depth + 1);
   }
-  if (cs.k === "never") return "true";
+  return "unknown";
+}
+function structuralExtends(check, ext, depth) {
+  const cs = slotsOfAbs(check);
+  const es = slotsOfAbs(ext);
+  if (!cs || !es) return "unknown";
+  const extKeys = Object.keys(es);
+  if (extKeys.length === 0) return "unknown";
+  const flags = [];
+  for (const key of extKeys) {
+    const target = es[key];
+    const source = cs[key];
+    if (source === void 0) {
+      flags.push("false");
+      continue;
+    }
+    flags.push(absExtends(source, target, depth + 1));
+  }
+  if (flags.some((f) => f === "false")) return "false";
+  if (flags.every((f) => f === "true")) 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;
+  const p = stripParens(pattern);
+  if (ts.isInferTypeNode(p)) {
+    const name = p.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.isArrayTypeNode(p) && actual.shape.k === "arr") {
+    return matchExtendsInfer(p.elementType, actual.shape.element, inferMap, depth + 1);
   }
-  if (ts.isTypeReferenceNode(pattern)) {
-    const name = typeNameString(pattern.typeName);
-    const args = pattern.typeArguments ?? [];
+  if (ts.isTypeReferenceNode(p)) {
+    const name = typeNameString(p.typeName);
+    const args = p.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);
     }
@@ -738,32 +1694,65 @@ function matchExtendsInfer(pattern, actual, inferMap, depth = 0) {
     }
     return "unknown";
   }
-  if (ts.isUnionTypeNode(pattern)) {
-    const flags = pattern.types.map((t) => matchExtendsInfer(t, actual, inferMap, depth + 1));
+  if (ts.isUnionTypeNode(p)) {
+    const flags = p.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";
   }
+  if (ts.isTypeLiteralNode(p)) {
+    const slots = slotsOfAbs(actual);
+    if (!slots) return "unknown";
+    const flags = [];
+    for (const member of p.members) {
+      if (!ts.isPropertySignature(member) || !member.type) continue;
+      const name = memberName(member);
+      if (name === void 0) continue;
+      const source = slots[name];
+      if (source === void 0) {
+        flags.push("false");
+        continue;
+      }
+      flags.push(matchExtendsInfer(member.type, source, inferMap, depth + 1));
+    }
+    if (flags.length === 0) return "unknown";
+    if (flags.some((f) => f === "false")) return "false";
+    if (flags.every((f) => f === "true")) return "true";
+    return "unknown";
+  }
   return "unknown";
 }
-function mapConditionalType(ctx, node, depth) {
+function mapConditionalType(ctx, node, depth, bindings) {
   const inferMap = /* @__PURE__ */ new Map();
   const inferNames = collectInferNames(node.extendsType);
-  const check = mapType(ctx, node.checkType, depth + 1);
+  const check = mapType(ctx, node.checkType, depth + 1, bindings);
   const astMatch = matchExtendsInfer(node.extendsType, check, inferMap);
-  const extAbs = mapType(ctx, node.extendsType, depth + 1);
-  const absMatch = astMatch !== "unknown" ? astMatch : absExtends(check, extAbs);
+  const extAbs = mapType(ctx, node.extendsType, depth + 1, bindings);
+  const checkSide = typeSideKind(ctx, node.checkType, depth + 1);
+  const extSide = typeSideKind(ctx, node.extendsType, depth + 1);
+  let absMatch;
+  if (extSide === "degraded" || checkSide === "degraded") {
+    absMatch = "unknown";
+  } else if (extSide === "unknownKeyword") {
+    absMatch = "true";
+  } else {
+    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);
+    const trueBindings = new Map(bindings ?? []);
+    for (const [k, v] of inferMap) trueBindings.set(`infer:${k}`, v);
+    const trueAbs = mapType(ctx, node.trueType, depth + 1, trueBindings);
+    const falseAbs = mapType(ctx, node.falseType, depth + 1, bindings);
     if (absMatch === "true") return trueAbs;
     if (absMatch === "false") return falseAbs;
-    if (condMeta && check.term?.op === "var") {
-      ctx.pendingCond = { ...condMeta, fallback: falseAbs };
+    if (condMeta && check.term?.op === "var" && trueBranchIsInferVar(node, condMeta)) {
+      if (isSignatureReturnPos(node)) {
+        ctx.pendingCond = { ...condMeta, fallback: falseAbs };
+      }
       return typeVarAbs(condMeta.inferVar);
     }
     return absUnion([trueAbs, falseAbs]);
@@ -771,10 +1760,18 @@ function mapConditionalType(ctx, node, depth) {
     ctx.typeParams = savedTp;
   }
 }
+function trueBranchIsInferVar(node, condMeta) {
+  const t = stripParens(node.trueType);
+  if (ts.isInferTypeNode(t)) return t.typeParameter.name.text === condMeta.inferVar;
+  if (ts.isTypeReferenceNode(t) && !(t.typeArguments && t.typeArguments.length > 0)) {
+    return typeNameString(t.typeName) === condMeta.inferVar;
+  }
+  return false;
+}
 function analyzeCondPattern(_ctx, node, check) {
   if (check.term?.op !== "var") return void 0;
   const fromVar = check.term.id;
-  const ext = node.extendsType;
+  const ext = stripParens(node.extendsType);
   const names = collectInferNames(ext);
   const inferVar = [...names][0];
   if (!inferVar) return void 0;
@@ -790,20 +1787,40 @@ function analyzeCondPattern(_ctx, node, check) {
   }
   return void 0;
 }
-function mapType(ctx, node, depth) {
+function mapType(ctx, node, depth, bindings) {
   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.isParenthesizedTypeNode(node)) return mapType(ctx, node.type, depth, bindings);
+  if (ts.isTypeReferenceNode(node)) return mapTypeRef(ctx, node, depth, bindings);
+  if (ts.isArrayTypeNode(node)) return absArr(mapType(ctx, node.elementType, depth, bindings));
   if (ts.isTupleTypeNode(node)) {
+    const elements = [];
+    let rest;
     for (const element of node.elements) {
-      const inner = ts.isNamedTupleMember(element) ? element.type : element;
-      return absArr(mapType(ctx, inner, depth));
+      if (ts.isNamedTupleMember(element)) {
+        let t = mapType(ctx, element.type, depth, bindings);
+        if (element.questionToken) t = absUnion([t, absUndefLit()]);
+        elements.push(t);
+        continue;
+      }
+      if (ts.isOptionalTypeNode(element)) {
+        elements.push(absUnion([mapType(ctx, element.type, depth, bindings), absUndefLit()]));
+        continue;
+      }
+      if (ts.isRestTypeNode(element)) {
+        rest = mapType(ctx, element.type, depth, bindings);
+        continue;
+      }
+      elements.push(mapType(ctx, element, depth, bindings));
     }
-    return absUnknown();
+    return makeAbs(
+      { k: "tuple", elements, ...rest ? { rest } : {} },
+      void 0,
+      void 0,
+      "exact"
+    );
   }
   if (ts.isUnionTypeNode(node)) {
-    const members = node.types.map((t) => mapType(ctx, t, depth));
+    const members = node.types.map((t) => mapType(ctx, t, depth, bindings));
     const hasLit = members.some((m) => m.term?.op === "lit");
     if (hasLit && members.length > 1) {
       return absExact({ k: "sum", members });
@@ -811,17 +1828,9 @@ function mapType(ctx, node, depth) {
     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);
-    }
+    const members = node.types.map((t) => mapType(ctx, t, depth, bindings));
+    const merged = mergeIntersection(members);
+    if (merged) return merged;
     return members[0] ?? absUnknown();
   }
   if (ts.isLiteralTypeNode(node)) {
@@ -842,22 +1851,61 @@ function mapType(ctx, node, depth) {
     if (ctor) {
       const params = [];
       for (const param of ctor.parameters) {
-        let type = param.type ? mapType(ctx, param.type, depth) : absUnknown();
+        let type = param.type ? mapType(ctx, param.type, depth, bindings) : absUnknown();
+        if (param.questionToken) type = absUnion([type, absUndefLit()]);
+        params.push(type);
+      }
+      const instance = ctor.type ? mapType(ctx, ctor.type, depth, bindings) : absUnknown();
+      const cond = takePendingCond(ctx);
+      const { properties: properties2 } = mapTypeMembers(ctx, node.members, depth, bindings);
+      return attachFnSlots(absCtorSig(params, instance, condExtra(cond)), properties2);
+    }
+    const call = node.members.find(ts.isCallSignatureDeclaration);
+    if (call) {
+      const params = [];
+      for (const param of call.parameters) {
+        let type = param.type ? mapType(ctx, param.type, depth, bindings) : absUnknown();
         if (param.questionToken) type = absUnion([type, absUndefLit()]);
         params.push(type);
       }
-      return absFnSig(params, ctor.type ? mapType(ctx, ctor.type, depth) : absUnknown());
+      const ret = call.type ? mapType(ctx, call.type, depth, bindings) : absUnknown();
+      const cond = takePendingCond(ctx);
+      const { properties: properties2 } = mapTypeMembers(ctx, node.members, depth, bindings);
+      return attachFnSlots(absFnSig(params, ret, condExtra(cond)), properties2);
     }
-    return absObj(mapTypeMembers(ctx, node.members, depth));
+    const { properties, index } = mapTypeMembers(ctx, node.members, depth, bindings);
+    if (index) return absOpenObj(properties, index);
+    return absObj(properties);
   }
   if (ts.isTypeOperatorNode(node)) {
-    return node.operator === ts.SyntaxKind.ReadonlyKeyword ? mapType(ctx, node.type, depth) : absUnknown();
+    if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+      return mapType(ctx, node.type, depth, bindings);
+    }
+    if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
+      const names = keyofNamesOf(ctx, node.type, depth);
+      if (!names) {
+        ctx.degradedMark++;
+        return absUnknown();
+      }
+      if (names.length === 0) return absNever();
+      return absExact({ k: "sum", members: names.map((n) => absLit(n)) });
+    }
+    ctx.degradedMark++;
+    return absUnknown();
   }
   if (ts.isConditionalTypeNode(node)) {
-    return mapConditionalType(ctx, node, depth);
+    const cond = mapConditionalType(ctx, node, depth, bindings);
+    if (isPlainUnknown(cond)) ctx.degradedMark++;
+    return cond;
   }
   if (ts.isInferTypeNode(node)) {
-    return typeVarAbs(node.typeParameter.name.text);
+    const name = node.typeParameter.name.text;
+    const bound = bindings?.get(`infer:${name}`);
+    if (bound) return bound;
+    return typeVarAbs(name);
+  }
+  if (ts.isTypePredicateNode(node)) {
+    return node.assertsModifier ? absUndefLit() : absPrim("boolean");
   }
   switch (node.kind) {
     case ts.SyntaxKind.StringKeyword:
@@ -882,6 +1930,7 @@ function mapType(ctx, node, depth) {
     case ts.SyntaxKind.NullKeyword:
       return absNullLit();
     default:
+      ctx.degradedMark++;
       return absUnknown();
   }
 }
@@ -889,6 +1938,7 @@ function indent(level) {
   return "  ".repeat(level);
 }
 function emitKey(key) {
+  if (key === "__proto__") return `["__proto__"]`;
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
 }
 function emitEntries(lines, record, level) {
@@ -912,6 +1962,9 @@ function emitAbs(a, expanding) {
       }
       return "absUnknown";
     case "any":
+      if (a.term?.op === "var") {
+        return `makeAbs({ k: "any" }, termVar(${JSON.stringify(a.term.id)}), undefined, "path")`;
+      }
       return "absUnknown";
     case "prim": {
       if (a.term?.op === "lit") {
@@ -923,6 +1976,12 @@ function emitAbs(a, expanding) {
       if (s.type === "number") return "num()";
       if (s.type === "string") return "str()";
       if (s.type === "boolean") return "bool()";
+      if (s.type === "bigint") {
+        return `makeAbs({ k: "prim", type: "bigint" }, undefined, undefined, "exact")`;
+      }
+      if (s.type === "symbol") {
+        return `makeAbs({ k: "prim", type: "symbol" }, undefined, undefined, "exact")`;
+      }
       return "absUnknown";
     }
     case "arr":
@@ -957,7 +2016,15 @@ function emitAbs(a, expanding) {
       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" })`;
+      const facets = [];
+      if (s.ctor !== void 0) facets.push(`f.shape.ctor = ${s.ctor ? "true" : "false"};`);
+      const slotEntries = Object.entries(s.slots ?? {});
+      if (slotEntries.length > 0) {
+        const entries = slotEntries.map(([key, slot]) => `${emitKey(key)}: { value: ${emitAbs(slot.value, expanding)} }`).join(", ");
+        facets.push(`f.shape.slots = { ${entries} };`);
+      }
+      if (facets.length === 0) return `relationFn([${params}], ${ret}, { conf: "exact" })`;
+      return `(() => { const f = relationFn([${params}], ${ret}, { conf: "exact" }); ${facets.join(" ")} return f; })()`;
     }
     default:
       return "absUnknown";
@@ -968,7 +2035,11 @@ function emitAbs(a, expanding) {
 import { readFileSync as readFileSync2, existsSync, statSync as statSync2, readdirSync } from "fs";
 import { basename, dirname, join } from "path";
 import ts2 from "typescript";
-import { toJsBindingIdent } from "@nudojs/core/internal";
+import {
+  formatObjectKey,
+  isJsBindingIdent,
+  toJsBindingIdent
+} from "@nudojs/core/internal";
 var BUILDERS = [
   "fn",
   "number",
@@ -977,38 +2048,52 @@ var BUILDERS = [
   "any",
   "shape",
   "array",
-  "lit",
-  "union"
+  "union",
+  "partial"
 ];
 function keywordDsl(node) {
   switch (node.kind) {
     case ts2.SyntaxKind.NumberKeyword:
-      return "number()";
+      return { dsl: "number()" };
     case ts2.SyntaxKind.StringKeyword:
-      return "string()";
+      return { dsl: "string()" };
     case ts2.SyntaxKind.BooleanKeyword:
-      return "boolean()";
+      return { dsl: "boolean()" };
+    // any / unknown：TS 语义就是「无约束」⇒ any() 是**忠实**映射
     case ts2.SyntaxKind.AnyKeyword:
     case ts2.SyntaxKind.UnknownKeyword:
+    // void 返回：调用方拿不到值 ⇒ 无返回义务
     case ts2.SyntaxKind.VoidKeyword:
-    case ts2.SyntaxKind.UndefinedKeyword:
-    case ts2.SyntaxKind.NullKeyword:
+    // object：非原始类型 ⇒ 无约束（宽松但不引入假红）
     case ts2.SyntaxKind.ObjectKeyword:
+      return { dsl: "any()" };
+    // null：TS 的**真 null 面**（不是 any()）——Bug 801
+    case ts2.SyntaxKind.NullKeyword:
+      return { dsl: "null", raw: true };
+    // undefined：TS 的**真 undefined 面**（union 里不能被 any() 吞掉）
+    case ts2.SyntaxKind.UndefinedKeyword:
+      return { dsl: "undefined", raw: true };
+    // never 是底类型：DSL 无底约束 ⇒ 标为未建模（不能静默放宽成 any()）
     case ts2.SyntaxKind.NeverKeyword:
-      return "any()";
+      return { unmodeled: "never (bottom type is not expressible)" };
     case ts2.SyntaxKind.BigIntKeyword:
+      return { unmodeled: "bigint" };
     case ts2.SyntaxKind.SymbolKeyword:
-      return void 0;
+      return { unmodeled: "symbol" };
     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)";
+  if (ts2.isStringLiteral(lit)) return { dsl: JSON.stringify(lit.text), modeled: true, raw: true };
+  if (ts2.isNumericLiteral(lit)) return { dsl: lit.text, modeled: true, raw: true };
+  if (lit.kind === ts2.SyntaxKind.TrueKeyword) return { dsl: "true", modeled: true, raw: true };
+  if (lit.kind === ts2.SyntaxKind.FalseKeyword) return { dsl: "false", modeled: true, raw: true };
+  if (lit.kind === ts2.SyntaxKind.NullKeyword) return { dsl: "null", modeled: true, raw: true };
+  if (ts2.isPrefixUnaryExpression(lit) && lit.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(lit.operand)) {
+    return { dsl: `-${lit.operand.text}`, modeled: true, raw: true };
+  }
   return void 0;
 }
 function typeRefName(node) {
@@ -1026,173 +2111,1001 @@ function typeRefName(node) {
   }
   return "?";
 }
-function typeToDsl(node, depth = 0) {
-  if (!node || depth > 6) return "any()";
+function memberKey(name) {
+  if (!name) return void 0;
+  if (ts2.isIdentifier(name)) return name.text;
+  if (ts2.isStringLiteral(name) || ts2.isNumericLiteral(name)) return name.text;
+  if (ts2.isComputedPropertyName(name)) {
+    const expr = name.expression;
+    if (ts2.isPropertyAccessExpression(expr) && ts2.isIdentifier(expr.expression) && expr.expression.text === "Symbol") {
+      if (expr.name.text === "iterator") return "@@iterator";
+      if (expr.name.text === "asyncIterator") return "@@asyncIterator";
+      return void 0;
+    }
+    if (ts2.isStringLiteral(expr)) return expr.text;
+    return void 0;
+  }
+  return void 0;
+}
+function memberKeyOrNote(name, what, ctx) {
+  const key = memberKey(name);
+  if (key !== void 0) return key;
+  ctx.notes.push(`${what} member with a name that cannot be resolved statically is not projected`);
+  return void 0;
+}
+function draftKey(key) {
+  if (key === "__proto__") return `["__proto__"]`;
+  return formatObjectKey(key);
+}
+function optionalize(d) {
+  const base = !d.raw ? d.dsl : d.dsl === "undefined" ? "union(undefined)" : `union(${d.dsl}, undefined)`;
+  return `${base}.optional()`;
+}
+function constraintSlot(d) {
+  return d.raw ? `union(${d.dsl})` : d.dsl;
+}
+function typeToDsl(node, ctx) {
+  if (!node) return void 0;
+  if (ctx.depth > 6) {
+    ctx.notes.push("type nesting too deep \u2192 any()");
+    return { dsl: "any()", modeled: false };
+  }
   const kw = keywordDsl(node);
-  if (kw !== void 0) return kw;
+  if (kw) {
+    if ("dsl" in kw) {
+      return { dsl: kw.dsl, modeled: true, ...kw.raw ? { raw: true } : {} };
+    }
+    ctx.notes.push(`unmodeled type '${kw.unmodeled}' \u2192 any()`);
+    return { dsl: "any()", modeled: false };
+  }
   if (ts2.isLiteralTypeNode(node)) {
-    return litDsl(node) ?? "any()";
+    return litDsl(node) ?? { dsl: "any()", modeled: false };
   }
   if (ts2.isArrayTypeNode(node)) {
-    const el = typeToDsl(node.elementType, depth + 1) ?? "any()";
-    return `array(${el})`;
+    const el = typeToDsl(node.elementType, child(ctx)) ?? { dsl: "any()", modeled: false };
+    return { dsl: `array(${el.dsl})`, modeled: el.modeled };
   }
   if (ts2.isUnionTypeNode(node)) {
-    const parts = node.types.map((t) => typeToDsl(t, depth + 1) ?? "any()");
-    if (parts.length === 0) return "any()";
+    const parts = [];
+    for (const t of node.types) {
+      const d = typeToDsl(t, child(ctx));
+      parts.push(d ?? { dsl: "any()", modeled: false });
+    }
+    if (parts.length === 0) return { dsl: "any()", modeled: false };
+    if (parts.some((p) => !p.modeled)) {
+      ctx.notes.push("union member not modeled \u2192 any()");
+      return { dsl: "any()", modeled: false };
+    }
     if (parts.length === 1) return parts[0];
-    return `union(${parts.join(", ")})`;
+    return { dsl: `union(${parts.map((p) => p.dsl).join(", ")})`, modeled: true };
   }
   if (ts2.isParenthesizedTypeNode(node)) {
-    return typeToDsl(node.type, depth + 1);
+    return typeToDsl(node.type, child(ctx));
   }
   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(", ")} })`;
+    const mark = noteMark(ctx);
+    const dsl = membersToShape(node.members, ctx);
+    return { dsl, modeled: ctx.notes.length === mark };
   }
   if (ts2.isFunctionTypeNode(node) || ts2.isConstructorTypeNode(node)) {
-    return fnSignatureDsl(node.parameters, node.type, depth);
+    return fnSignatureDsl(node.parameters, node.type, ctx);
+  }
+  if (ts2.isConditionalTypeNode(node)) {
+    return conditionalDsl(node, ctx);
   }
   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()"})`;
+    return typeRefDsl(node, ctx);
+  }
+  if (ts2.isExpressionWithTypeArguments(node)) {
+    ctx.notes.push("unmodeled type reference \u2192 any()");
+    return { dsl: "any()", modeled: false };
+  }
+  ctx.notes.push("unmodeled type \u2192 any()");
+  return { dsl: "any()", modeled: false };
+}
+function conditionalDsl(node, ctx) {
+  const ext = ts2.isParenthesizedTypeNode(node.extendsType) ? node.extendsType.type : node.extendsType;
+  if (ext.kind === ts2.SyntaxKind.UnknownKeyword) {
+    const t2 = typeToDsl(node.trueType, child(ctx));
+    ctx.notes.push(
+      "conditional type \u2014 the extends side is `unknown` (always true); only the true branch is projected"
+    );
+    if (!t2) return { dsl: "any()", modeled: false };
+    return { dsl: t2.dsl, modeled: false, ...t2.raw ? { raw: true } : {} };
+  }
+  const t = typeToDsl(node.trueType, child(ctx));
+  const f = typeToDsl(node.falseType, child(ctx));
+  if (!t || !f || !t.modeled || !f.modeled) {
+    ctx.notes.push(
+      "conditional type \u2014 not decidable from the declaration and its branches are not modeled \u2192 any() (same as the harvest face's undecidable branch)"
+    );
+    return { dsl: "any()", modeled: false };
+  }
+  ctx.notes.push(
+    "conditional type \u2014 not decidable from the declaration; both branches are projected (union), same as the harvest face"
+  );
+  if (t.dsl === f.dsl) {
+    return { dsl: t.dsl, modeled: false, ...t.raw ? { raw: true } : {} };
+  }
+  return { dsl: `union(${t.dsl}, ${f.dsl})`, modeled: false };
+}
+function noteMark(ctx) {
+  return ctx.notes.length;
+}
+function child(ctx) {
+  return {
+    symbols: ctx.symbols,
+    notes: ctx.notes,
+    depth: ctx.depth + 1,
+    resolving: ctx.resolving,
+    lost: ctx.lost
+  };
+}
+function literalKeys(node) {
+  if (!node) return void 0;
+  if (ts2.isLiteralTypeNode(node)) {
+    const lit = node.literal;
+    if (ts2.isStringLiteral(lit) || ts2.isNumericLiteral(lit)) return [lit.text];
+    return void 0;
+  }
+  if (ts2.isUnionTypeNode(node)) {
+    const out = [];
+    for (const t of node.types) {
+      const k = literalKeys(t);
+      if (!k) return void 0;
+      out.push(...k);
     }
-    if (name === "Promise") {
-      return args[0] ? typeToDsl(args[0], depth + 1) : "any()";
+    return out.length > 0 ? out : void 0;
+  }
+  return void 0;
+}
+function recordDsl(args, ctx) {
+  const val = args[1] ? typeToDsl(args[1], child(ctx)) : void 0;
+  const keys = literalKeys(args[0]);
+  if (keys && keys.length > 0 && val) {
+    const fields = keys.map((k) => `${draftKey(k)}: ${val.dsl}`);
+    return { dsl: `shape({ ${fields.join(", ")} })`, modeled: val.modeled };
+  }
+  ctx.notes.push(
+    "Record value domain is NOT modeled \u2014 the contract DSL has no index signature, so this position only requires an object (weaker than TypeScript)"
+  );
+  return { dsl: "shape({})", modeled: false };
+}
+function partialDsl(args, ctx) {
+  const inner = args[0];
+  if (!inner) {
+    ctx.notes.push("Partial<> without a type argument \u2192 any()");
+    return { dsl: "any()", modeled: false };
+  }
+  const d = typeToDsl(inner, child(ctx));
+  if (!d) {
+    ctx.notes.push("Partial<T> over an unmodeled type \u2192 any()");
+    return { dsl: "any()", modeled: false };
+  }
+  if (!d.dsl.startsWith("shape(")) {
+    ctx.notes.push("Partial<T> over a non-shape type is not expressible \u2192 any()");
+    return { dsl: "any()", modeled: false };
+  }
+  return { dsl: `partial(${d.dsl})`, modeled: d.modeled };
+}
+function typeRefDsl(node, ctx) {
+  const name = typeRefName(node);
+  const args = node.typeArguments ?? [];
+  if (name === "Array" || name === "ReadonlyArray" || name === "readonly") {
+    const el = args[0] ? typeToDsl(args[0], child(ctx)) : void 0;
+    return { dsl: `array(${el?.dsl ?? "any()"})`, modeled: el?.modeled ?? false };
+  }
+  if (name === "Promise" || name === "PromiseLike") {
+    ctx.notes.push(
+      `${name}<\u2026> is not modeled \u2014 the Promise shell is kept (same as the harvest face); this position carries no constraint`
+    );
+    return { dsl: "any()", modeled: false };
+  }
+  if (name === "Record") return recordDsl(args, ctx);
+  if (name === "Partial") return partialDsl(args, ctx);
+  const alias = lookupAlias(name, ctx);
+  if (alias) {
+    if (ctx.resolving.has(name)) {
+      ctx.notes.push(`type alias '${name}' is recursive \u2192 any()`);
+      return { dsl: "any()", modeled: false };
+    }
+    ctx.resolving.add(name);
+    const d = typeToDsl(alias.type, child(ctx));
+    ctx.resolving.delete(name);
+    if (!d) {
+      ctx.notes.push(`type alias '${name}' has no type \u2192 any()`);
+      return { dsl: "any()", modeled: false };
+    }
+    return d;
+  }
+  const iface = lookupInterface(name, ctx);
+  if (iface) {
+    const mark = noteMark(ctx);
+    ctx.resolving.add(name);
+    const dsl = membersToShape(interfaceMembers(iface, ctx), ctx);
+    ctx.resolving.delete(name);
+    return { dsl, modeled: ctx.notes.length === mark };
+  }
+  ctx.notes.push(`unmodeled type reference '${name}' \u2192 any()`);
+  return { dsl: "any()", modeled: false };
+}
+function lookupInterface(name, ctx) {
+  if (!name.includes(".")) return ctx.symbols.interfaces.get(name);
+  const qualified = ctx.symbols.qualifiedInterfaces.get(name);
+  if (qualified) return qualified;
+  const short = name.slice(name.lastIndexOf(".") + 1);
+  const decl = ctx.symbols.interfaces.get(short);
+  if (decl && inAmbientModuleBlock2(decl)) return decl;
+  return void 0;
+}
+function lookupAlias(name, ctx) {
+  if (!name.includes(".")) return ctx.symbols.aliases.get(name);
+  const qualified = ctx.symbols.qualifiedAliases.get(name);
+  if (qualified) return qualified;
+  const short = name.slice(name.lastIndexOf(".") + 1);
+  const decl = ctx.symbols.aliases.get(short);
+  if (decl && inAmbientModuleBlock2(decl)) return decl;
+  return void 0;
+}
+function inAmbientModuleBlock2(decl) {
+  let node = decl.parent;
+  while (node) {
+    if (ts2.isModuleDeclaration(node) && ts2.isStringLiteral(node.name)) return true;
+    node = node.parent;
+  }
+  return false;
+}
+function interfaceMembers(iface, ctx) {
+  const out = [];
+  for (const clause of iface.heritageClauses ?? []) {
+    if (clause.token !== ts2.SyntaxKind.ExtendsKeyword) continue;
+    for (const t of clause.types) {
+      const name = heritageBaseName2(t);
+      const base = name ? lookupInterface(name, ctx) : void 0;
+      if (!base || !name) {
+        ctx.notes.push(
+          `interface '${iface.name.text}' extends ${name ?? "a non-local type"} \u2014 the inherited members are not modeled`
+        );
+        continue;
+      }
+      if (ctx.resolving.has(name)) {
+        ctx.notes.push(`interface '${name}' is recursive \u2014 the inherited members are not modeled`);
+        continue;
+      }
+      ctx.resolving.add(name);
+      out.push(...interfaceMembers(base, ctx));
+      ctx.resolving.delete(name);
     }
-    if (name === "Record") {
-      const val = args[1] ? typeToDsl(args[1], depth + 1) : "any()";
-      return `shape({}) /* open Record \u2192 ${val ?? "any()"} */`;
+  }
+  out.push(...iface.members);
+  return out;
+}
+function heritageBaseName2(t) {
+  const expr = t.expression;
+  if (ts2.isIdentifier(expr)) return expr.text;
+  if (ts2.isPropertyAccessExpression(expr) && ts2.isIdentifier(expr.expression) && ts2.isIdentifier(expr.name)) {
+    return `${expr.expression.text}.${expr.name.text}`;
+  }
+  return void 0;
+}
+function membersToShape(members, ctx) {
+  const fields = [];
+  let dropped = 0;
+  for (const m of members) {
+    const field = memberToField(m, ctx);
+    if (field === void 0) {
+      dropped++;
+      continue;
     }
-    if (name === "Partial" && args[0]) {
-      const inner = typeToDsl(args[0], depth + 1);
-      return inner ?? "any()";
+    fields.push(field);
+  }
+  if (fields.length === 0) {
+    if (dropped > 0) {
+      ctx.notes.push("all members of the type are unmodeled \u2192 any()");
+      return "any()";
     }
+    return "shape({})";
+  }
+  return `shape({ ${fields.join(", ")} })`;
+}
+function memberToField(m, ctx) {
+  if (ts2.isPropertySignature(m)) {
+    const key = memberKeyOrNote(m.name, "property", ctx);
+    if (key === void 0) return void 0;
+    const d = typeToDsl(m.type, child(ctx)) ?? { dsl: "any()", modeled: false };
+    const v = m.questionToken ? optionalize(d) : d.dsl;
+    return `${draftKey(key)}: ${v}`;
+  }
+  if (ts2.isMethodSignature(m)) {
+    const key = memberKeyOrNote(m.name, "method", ctx);
+    if (key === void 0) return void 0;
+    const d = fnSignatureDsl(m.parameters, m.type, ctx);
+    const v = m.questionToken ? optionalize(d) : d.dsl;
+    return `${draftKey(key)}: ${v}`;
+  }
+  if (ts2.isIndexSignatureDeclaration(m)) {
+    ctx.notes.push("index signature member is not modeled (the contract DSL has no index signature)");
     return void 0;
   }
-  if (ts2.isExpressionWithTypeArguments(node)) {
+  if (ts2.isCallSignatureDeclaration(m) || ts2.isConstructSignatureDeclaration(m)) {
+    ctx.notes.push("call/construct signature member is not modeled");
     return void 0;
   }
+  if (ts2.isGetAccessorDeclaration(m) || ts2.isSetAccessorDeclaration(m)) {
+    ctx.notes.push("accessor member is not modeled");
+    return void 0;
+  }
+  ctx.notes.push("member of an unsupported form is not projected");
   return void 0;
 }
-function fnSignatureDsl(params, ret, depth) {
-  const fields = [];
-  const notes = [];
+function paramSlots(params, ctx) {
+  const out = [];
   params.forEach((p, i) => {
-    let name;
-    if (p.name && ts2.isIdentifier(p.name)) name = p.name.text;
-    else name = `p${i}`;
+    const name = p.name && ts2.isIdentifier(p.name) ? p.name.text : `p${i}`;
+    if (name === "this") return;
     if (p.dotDotDotToken) {
-      notes.push(`${name}: rest \u2014 array()`);
-      fields.push(`${name}: array(any())`);
+      ctx.notes.push(`${name}: rest parameter \u2192 array(any())`);
+      out.push({ name, optional: false, dsl: "array(any())", modeled: false });
       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()";
+    const optional = Boolean(p.questionToken) || Boolean(p.initializer);
+    const d = typeToDsl(p.type, child(ctx));
+    if (!d) {
+      ctx.notes.push(`${name}: no type annotation \u2192 any()`);
+      out.push({ name, optional, dsl: "any()", modeled: false, plain: true });
+      return;
     }
-    fields.push(optional ? `${name}: ${dsl}.optional()` : `${name}: ${dsl}`);
+    out.push({
+      name,
+      optional,
+      dsl: d.dsl,
+      ...d.raw ? { raw: true } : {},
+      modeled: d.modeled
+    });
   });
-  let retDsl = typeToDsl(ret, depth + 1);
-  if (retDsl === void 0) {
-    notes.push(`returns: unmodeled \u2192 any()`);
-    retDsl = "any()";
+  return out;
+}
+function slotText(s) {
+  if (s.plain) return s.dsl;
+  if (!s.optional) return s.dsl;
+  return optionalize({
+    dsl: s.dsl,
+    modeled: s.modeled,
+    ...s.raw ? { raw: true } : {}
+  });
+}
+function slotsToDsl(slots) {
+  const fields = slots.map((s) => `${s.name}: ${slotText(s)}`);
+  return fields.length === 0 ? "{}" : `{ ${fields.join(", ")} }`;
+}
+function paramsDsl(params, ctx) {
+  return slotsToDsl(paramSlots(params, ctx));
+}
+function mergeParamSlots(per) {
+  const first = per[0];
+  if (!first || first.length === 0) return void 0;
+  const out = [];
+  for (let i = 0; i < first.length; i++) {
+    const slot = first[i];
+    const texts = [];
+    let ok = true;
+    for (const slots of per) {
+      const s = slots[i];
+      if (!s || s.optional !== slot.optional || !s.modeled || !slot.modeled) {
+        ok = false;
+        break;
+      }
+      if (!texts.includes(s.dsl)) texts.push(s.dsl);
+    }
+    if (!ok) return void 0;
+    const mergedText = texts.length === 1 ? texts[0] : `union(${texts.join(", ")})`;
+    out.push({
+      name: slot.name,
+      optional: slot.optional,
+      dsl: mergedText,
+      modeled: true,
+      ...texts.length === 1 && slot.raw ? { raw: true } : {}
+    });
+  }
+  return out;
+}
+function fnSignatureDsl(params, ret, ctx) {
+  const p = paramsDsl(params, ctx);
+  const r = typeToDsl(ret, child(ctx));
+  if (!r) {
+    return { dsl: `fn(${p}, any())`, modeled: true };
   }
-  const obj = fields.length === 0 ? "{}" : `{ ${fields.join(", ")} }`;
-  return `fn(${obj}, ${retDsl})`;
+  return { dsl: `fn(${p}, ${constraintSlot(r)})`, modeled: r.modeled };
 }
 function pickName(decl) {
   return decl.name && ts2.isIdentifier(decl.name) ? decl.name.text : void 0;
 }
+function isExported(stmt) {
+  const mods = stmt.modifiers;
+  return mods?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword) ?? false;
+}
+function isDefaultExported(stmt) {
+  const mods = stmt.modifiers;
+  return mods?.some((m) => m.kind === ts2.SyntaxKind.DefaultKeyword) ?? false;
+}
+function collectSymbols(sf) {
+  const aliases = /* @__PURE__ */ new Map();
+  const interfaces = /* @__PURE__ */ new Map();
+  const qualifiedAliases = /* @__PURE__ */ new Map();
+  const qualifiedInterfaces = /* @__PURE__ */ new Map();
+  const walk = (stmts, ns) => {
+    for (const stmt of stmts) {
+      if (ts2.isTypeAliasDeclaration(stmt)) {
+        if (!aliases.has(stmt.name.text)) aliases.set(stmt.name.text, stmt);
+        const q = [...ns, stmt.name.text].join(".");
+        if (q !== stmt.name.text && !qualifiedAliases.has(q)) qualifiedAliases.set(q, stmt);
+      } else if (ts2.isInterfaceDeclaration(stmt)) {
+        if (!interfaces.has(stmt.name.text)) interfaces.set(stmt.name.text, stmt);
+        const q = [...ns, stmt.name.text].join(".");
+        if (q !== stmt.name.text && !qualifiedInterfaces.has(q)) qualifiedInterfaces.set(q, stmt);
+      } else if (ts2.isModuleDeclaration(stmt) && stmt.body && ts2.isModuleBlock(stmt.body) && ts2.isIdentifier(stmt.name) && stmt.name.text !== "global") {
+        walk(stmt.body.statements, [...ns, stmt.name.text]);
+      }
+    }
+  };
+  walk(sf.statements, []);
+  return { aliases, interfaces, qualifiedAliases, qualifiedInterfaces };
+}
+function collectLocals(stmts) {
+  const out = /* @__PURE__ */ new Map();
+  const put = (name, stmt) => {
+    if (name && !out.has(name)) out.set(name, stmt);
+  };
+  for (const stmt of stmts) {
+    if (ts2.isVariableStatement(stmt)) {
+      for (const d of stmt.declarationList.declarations) put(pickName(d), stmt);
+      continue;
+    }
+    if (ts2.isFunctionDeclaration(stmt) || ts2.isClassDeclaration(stmt) || ts2.isEnumDeclaration(stmt) || ts2.isModuleDeclaration(stmt)) {
+      put(pickName(stmt), stmt);
+    }
+  }
+  return out;
+}
+function takeNotes(ctx) {
+  const out = ctx.notes.slice();
+  ctx.notes.length = 0;
+  return out;
+}
+function enumMemberValue(m, counter, ctx) {
+  const init = m.initializer;
+  if (!init) {
+    const v = counter.value;
+    counter.value = v + 1;
+    return String(v);
+  }
+  if (ts2.isStringLiteral(init)) return JSON.stringify(init.text);
+  if (ts2.isNumericLiteral(init)) {
+    const v = Number(init.text);
+    counter.value = v + 1;
+    return init.text;
+  }
+  if (ts2.isPrefixUnaryExpression(init) && init.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(init.operand)) {
+    const v = -Number(init.operand.text);
+    counter.value = v + 1;
+    return `-${init.operand.text}`;
+  }
+  ctx.notes.push("enum member with a computed initializer is not projected");
+  return void 0;
+}
+function namespaceMemberField(stmt, ctx) {
+  if (!isExported(stmt)) return void 0;
+  if (ts2.isVariableStatement(stmt)) {
+    const fields = [];
+    for (const d of stmt.declarationList.declarations) {
+      const name = pickName(d);
+      if (!name) continue;
+      if (d.type) {
+        const t = typeToDsl(d.type, child(ctx));
+        if (!t) continue;
+        fields.push(`${draftKey(name)}: ${t.dsl}`);
+        continue;
+      }
+      const init = d.initializer;
+      if (init && (ts2.isStringLiteral(init) || ts2.isNumericLiteral(init))) {
+        const raw = ts2.isStringLiteral(init) ? JSON.stringify(init.text) : init.text;
+        fields.push(`${draftKey(name)}: ${raw}`);
+        continue;
+      }
+      ctx.notes.push(`namespace member '${name}' has no inferable value type`);
+    }
+    return fields.length > 0 ? fields.join(", ") : void 0;
+  }
+  if (ts2.isFunctionDeclaration(stmt)) {
+    const name = pickName(stmt);
+    if (!name) return void 0;
+    const d = fnSignatureDsl(stmt.parameters, stmt.type, ctx);
+    return `${draftKey(name)}: ${d.dsl}`;
+  }
+  if (ts2.isEnumDeclaration(stmt)) {
+    const name = pickName(stmt);
+    if (!name) return void 0;
+    const inner = enumShape(stmt, ctx);
+    return `${draftKey(name)}: ${inner}`;
+  }
+  if (ts2.isModuleDeclaration(stmt)) {
+    const name = pickName(stmt);
+    if (!name || !stmt.body || !ts2.isModuleBlock(stmt.body)) return void 0;
+    const fields = [];
+    for (const inner of stmt.body.statements) {
+      const f = namespaceMemberField(inner, ctx);
+      if (f) fields.push(f);
+    }
+    return `${draftKey(name)}: shape({ ${fields.join(", ")} })`;
+  }
+  return void 0;
+}
+function enumShape(decl, ctx) {
+  const fields = [];
+  const counter = { value: 0 };
+  for (const m of decl.members) {
+    const key = memberKey(m.name);
+    if (key === void 0) {
+      ctx.notes.push("enum member with a computed name is not projected");
+      continue;
+    }
+    const value = enumMemberValue(m, counter, ctx);
+    if (value === void 0) continue;
+    fields.push(`${draftKey(key)}: ${value}`);
+  }
+  return fields.length === 0 ? "shape({})" : `shape({ ${fields.join(", ")} })`;
+}
+function mergeOverloads(decls, ctx) {
+  const first = decls[0];
+  if (decls.length === 1) {
+    const d = fnSignatureDsl(first.parameters, first.type, ctx);
+    return {
+      dsl: d,
+      sigs: [d.dsl],
+      paramsMerged: true,
+      arity: arityOf(first),
+      arityDiffers: false
+    };
+  }
+  const slotsPer = [];
+  const rets = [];
+  const sigs = [];
+  for (const d of decls) {
+    const slots = paramSlots(d.parameters, ctx);
+    slotsPer.push(slots);
+    const params = slotsToDsl(slots);
+    const r = typeToDsl(d.type, child(ctx));
+    const ret2 = r ?? { dsl: "any()", modeled: true };
+    rets.push(ret2);
+    sigs.push(`fn(${params}, ${constraintSlot(ret2)})`);
+  }
+  const arity = slotsPer[0].length;
+  const arityDiffers = slotsPer.some((s) => s.length !== arity);
+  const merged = arityDiffers ? void 0 : mergeParamSlots(slotsPer);
+  const p = slotsToDsl(merged ?? slotsPer[0]);
+  if (rets.some((r) => !r.modeled)) {
+    ctx.notes.push("an overload return type is not modeled \u2192 any()");
+    return {
+      dsl: { dsl: `fn(${p}, any())`, modeled: false },
+      sigs,
+      paramsMerged: merged !== void 0,
+      arity,
+      arityDiffers
+    };
+  }
+  const uniq = /* @__PURE__ */ new Map();
+  for (const r of rets) if (!uniq.has(r.dsl)) uniq.set(r.dsl, r);
+  const texts = [...uniq.values()];
+  const ret = texts.length === 1 ? constraintSlot(texts[0]) : `union(${texts.map((r) => r.dsl).join(", ")})`;
+  return {
+    dsl: { dsl: `fn(${p}, ${ret})`, modeled: true },
+    sigs,
+    paramsMerged: merged !== void 0,
+    arity,
+    arityDiffers
+  };
+}
+function arityOf(d) {
+  let n = 0;
+  for (const p of d.parameters) {
+    if (p.name && ts2.isIdentifier(p.name) && p.name.text === "this") continue;
+    n++;
+  }
+  return n;
+}
 function collectExports(sourceFile) {
+  const symbols = collectSymbols(sourceFile);
+  const ctx = {
+    symbols,
+    notes: [],
+    depth: 0,
+    resolving: /* @__PURE__ */ new Set(),
+    lost: { n: 0 }
+  };
   const out = [];
+  const fnGroups = /* @__PURE__ */ new Map();
+  const emittedFns = /* @__PURE__ */ new Set();
   const push = (e) => {
+    const notes = takeNotes(ctx);
+    if (notes.length > 0) {
+      e.note = e.note ? `${e.note}; ${notes.join("; ")}` : notes.join("; ");
+      if (e.dsl !== void 0) e.partial = true;
+    }
     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;
+  const pushScoped = (e, ambient) => {
+    if (ambient) {
+      e.note = e.note ? `${e.note}; ${ambient}` : ambient;
+      if (e.dsl !== void 0) e.partial = true;
     }
-    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" });
+    push(e);
+  };
+  const fnDecl = (stmt, name, ambient) => {
+    const group = fnGroups.get(name);
+    if (group) group.decls.push(stmt);
+    else fnGroups.set(name, { decls: [stmt], ambient });
+  };
+  const collectStatements2 = (stmts, prefix, ambient) => {
+    const locals = collectLocals(stmts);
+    for (const stmt of stmts) {
+      if (ts2.isFunctionDeclaration(stmt)) {
+        const exported = isExported(stmt);
+        const isDefault = isDefaultExported(stmt);
+        if (!exported && !isDefault) continue;
+        const name = isDefault ? "default" : pickName(stmt);
+        if (!name) {
+          pushScoped(
+            {
+              name: `${prefix}default`,
+              note: "anonymous default function is not projected",
+              kind: "other"
+            },
+            ambient
+          );
+          continue;
         }
+        fnDecl(stmt, `${prefix}${name}`, ambient);
+        continue;
       }
-      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" });
+      if (ts2.isVariableStatement(stmt)) {
+        if (!isExported(stmt)) continue;
+        for (const d of stmt.declarationList.declarations) {
+          const name = pickName(d);
+          if (!name) continue;
+          const t = typeToDsl(d.type, ctx);
+          if (!t) {
+            pushScoped(
+              {
+                name: `${prefix}${name}`,
+                note: "no type annotation \u2014 the value is not projected",
+                kind: "value"
+              },
+              ambient
+            );
+            continue;
+          }
+          pushScoped(
+            {
+              name: `${prefix}${name}`,
+              dsl: constraintSlot(t),
+              kind: t.dsl.startsWith("fn(") ? "function" : "value",
+              ...t.modeled ? {} : { partial: true }
+            },
+            ambient
+          );
+        }
+        continue;
+      }
+      if (ts2.isClassDeclaration(stmt)) {
+        if (!isExported(stmt) && !isDefaultExported(stmt)) continue;
+        const name = isDefaultExported(stmt) ? "default" : pickName(stmt);
+        if (!name) {
+          pushScoped(
+            { name: `${prefix}default`, note: "anonymous class is not projected", kind: "class" },
+            ambient
+          );
+          continue;
+        }
+        const ctor = stmt.members.find(ts2.isConstructorDeclaration);
+        if (ctor) {
+          const slots = paramSlots(ctor.parameters, ctx);
+          pushScoped(
+            {
+              name: `${prefix}${name}`,
+              dsl: `fn(${slotsToDsl(slots)}, any())`,
+              kind: "class",
+              note: "constructor signature projected as a plain fn \u2014 the contract DSL has no `new` semantics, and the instance side is not modeled",
+              partial: true
+            },
+            ambient
+          );
+        }
+        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;
+            const d = fnSignatureDsl(m.parameters, m.type, ctx);
+            pushScoped(
+              {
+                name: `${prefix}${name}.${mname}`,
+                dsl: d.dsl,
+                kind: "function",
+                ...d.modeled ? {} : { partial: true }
+              },
+              ambient
+            );
+          }
+        }
+        if (!anyMethod && !ctor) {
+          pushScoped(
+            {
+              name: `${prefix}${name}`,
+              note: "class without public methods projected",
+              kind: "class"
+            },
+            ambient
+          );
+        }
         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 (ts2.isEnumDeclaration(stmt)) {
+        if (!isExported(stmt) && !isDefaultExported(stmt)) continue;
+        const name = isDefaultExported(stmt) ? "default" : pickName(stmt);
+        if (!name) {
+          pushScoped(
+            { name: `${prefix}enum`, note: "anonymous enum is not projected", kind: "other" },
+            ambient
+          );
+          continue;
         }
+        const dsl = enumShape(stmt, ctx);
+        pushScoped({ name: `${prefix}${name}`, dsl, kind: "value" }, ambient);
+        continue;
       }
-      if (!anyMethod) {
-        push({ name, note: "class without public methods projected", kind: "class" });
+      if (ts2.isModuleDeclaration(stmt)) {
+        if (ts2.isStringLiteral(stmt.name)) {
+          const modName = stmt.name.text;
+          if (!stmt.body || !ts2.isModuleBlock(stmt.body)) {
+            pushScoped(
+              {
+                name: `${prefix}${modName}`,
+                note: "ambient module without a body is not projected",
+                kind: "other"
+              },
+              ambient
+            );
+            continue;
+          }
+          collectStatements2(
+            stmt.body.statements,
+            `${prefix}${modName}.`,
+            `ambient module "${modName}" \u2014 not an export of this file (review before accepting)`
+          );
+          continue;
+        }
+        if (ts2.isIdentifier(stmt.name) && stmt.name.text === "global") {
+          if (!stmt.body || !ts2.isModuleBlock(stmt.body)) {
+            pushScoped(
+              { name: `${prefix}global`, note: "ambient global without a body", kind: "other" },
+              ambient
+            );
+            continue;
+          }
+          collectStatements2(
+            stmt.body.statements,
+            `${prefix}global.`,
+            `ambient global declaration \u2014 not an export of this file (review before accepting)`
+          );
+          continue;
+        }
+        if (!isExported(stmt) && !isDefaultExported(stmt)) continue;
+        const name = isDefaultExported(stmt) ? "default" : pickName(stmt);
+        if (!name) {
+          pushScoped(
+            { name: `${prefix}namespace`, note: "anonymous namespace is not projected", kind: "other" },
+            ambient
+          );
+          continue;
+        }
+        if (!stmt.body || !ts2.isModuleBlock(stmt.body)) {
+          pushScoped(
+            {
+              name: `${prefix}${name}`,
+              note: "namespace with a qualified name is not projected",
+              kind: "other"
+            },
+            ambient
+          );
+          continue;
+        }
+        const fields = [];
+        for (const inner of stmt.body.statements) {
+          const f = namespaceMemberField(inner, ctx);
+          if (f) fields.push(f);
+        }
+        pushScoped(
+          {
+            name: `${prefix}${name}`,
+            dsl: fields.length > 0 ? `shape({ ${fields.join(", ")} })` : "shape({})",
+            kind: "value"
+          },
+          ambient
+        );
+        continue;
+      }
+      if (ts2.isExportDeclaration(stmt)) {
+        const spec = stmt.moduleSpecifier?.getText(sourceFile);
+        if (!stmt.exportClause) {
+          pushScoped(
+            {
+              name: spec ? `export * from ${spec}` : "export *",
+              note: "star re-export \u2014 the exported names are unknown, so nothing is projected",
+              kind: "other"
+            },
+            ambient
+          );
+          continue;
+        }
+        if (ts2.isNamespaceExport(stmt.exportClause)) {
+          pushScoped(
+            {
+              name: `${prefix}${stmt.exportClause.name.text}`,
+              note: `namespace re-export${spec ? ` from ${spec}` : ""} is not projected`,
+              kind: "other"
+            },
+            ambient
+          );
+          continue;
+        }
+        for (const el of stmt.exportClause.elements) {
+          const exported = el.name.text;
+          if (spec) {
+            pushScoped(
+              {
+                name: `${prefix}${exported}`,
+                note: `re-export from ${spec} is not projected`,
+                kind: "other"
+              },
+              ambient
+            );
+            continue;
+          }
+          const localName = el.propertyName?.text ?? el.name.text;
+          const local = locals.get(localName);
+          if (!local) {
+            pushScoped(
+              {
+                name: `${prefix}${exported}`,
+                note: `local re-export of '${localName}' \u2014 the local declaration was not found`,
+                kind: "other"
+              },
+              ambient
+            );
+            continue;
+          }
+          const projected = projectLocal(local, localName, exported, ctx);
+          pushScoped({ ...projected, name: `${prefix}${projected.name}` }, ambient);
+        }
+        continue;
+      }
+      if (ts2.isExportAssignment(stmt)) {
+        pushScoped(
+          {
+            name: `${prefix}default`,
+            note: "export assignment \u2014 bind via sidecar default",
+            kind: "other"
+          },
+          ambient
+        );
+        continue;
+      }
+      if (ts2.isImportEqualsDeclaration(stmt)) {
+        if (!isExported(stmt)) continue;
+        const name = pickName(stmt);
+        pushScoped(
+          {
+            name: `${prefix}${name ?? "import="}`,
+            note: "import-equals export \u2014 the aliased module value is not projected",
+            kind: "other"
+          },
+          ambient
+        );
+        continue;
+      }
+      if (ts2.isInterfaceDeclaration(stmt) || ts2.isTypeAliasDeclaration(stmt)) {
+        continue;
       }
-      continue;
     }
-    if (ts2.isExportAssignment(stmt)) {
-      push({ name: "default", note: "export assignment \u2014 bind via sidecar default", kind: "other" });
-      continue;
+  };
+  collectStatements2(sourceFile.statements, "", void 0);
+  for (const [name, group] of fnGroups) {
+    if (emittedFns.has(name)) continue;
+    emittedFns.add(name);
+    const decls = group.decls;
+    const m = mergeOverloads(decls, ctx);
+    if (decls.length > 1) {
+      ctx.lost.n += decls.length - 1;
     }
-    if (ts2.isInterfaceDeclaration(stmt) || ts2.isTypeAliasDeclaration(stmt)) {
-      continue;
+    const paramNote = m.paramsMerged ? "parameters merged position by position (union per position)" : m.arityDiffers ? `parameters from the first (arity ${m.arity} \u2014 calls with more arguments are not covered; the contract DSL has no overload set)` : "parameters from the first (the overload parameter types could not be merged)";
+    pushScoped(
+      {
+        name,
+        dsl: m.dsl.dsl,
+        kind: "function",
+        ...decls.length > 1 ? {
+          note: `${decls.length} overloads merged \u2014 ${paramNote}, return = union of all; overloads: ${m.sigs.join(" | ")}`
+        } : {},
+        ...m.dsl.modeled ? {} : { partial: true }
+      },
+      group.ambient
+    );
+  }
+  return { exports: out, lost: ctx.lost.n };
+}
+function projectLocal(stmt, localName, exported, ctx) {
+  if (ts2.isFunctionDeclaration(stmt)) {
+    const d = fnSignatureDsl(stmt.parameters, stmt.type, ctx);
+    return {
+      name: exported,
+      dsl: d.dsl,
+      kind: "function",
+      ...d.modeled ? {} : { partial: true }
+    };
+  }
+  if (ts2.isVariableStatement(stmt)) {
+    for (const decl of stmt.declarationList.declarations) {
+      if (pickName(decl) !== localName) continue;
+      const t = typeToDsl(decl.type, ctx);
+      if (!t) {
+        return {
+          name: exported,
+          note: "no type annotation \u2014 the value is not projected",
+          kind: "value"
+        };
+      }
+      return {
+        name: exported,
+        dsl: constraintSlot(t),
+        kind: t.dsl.startsWith("fn(") ? "function" : "value",
+        ...t.modeled ? {} : { partial: true }
+      };
     }
   }
-  return out;
+  if (ts2.isEnumDeclaration(stmt)) {
+    return { name: exported, dsl: enumShape(stmt, ctx), kind: "value" };
+  }
+  if (ts2.isClassDeclaration(stmt)) {
+    return {
+      name: exported,
+      note: "class re-export is not projected",
+      kind: "class"
+    };
+  }
+  return {
+    name: exported,
+    note: `local re-export of '${localName}' is not projected`,
+    kind: "other"
+  };
+}
+function draftIdentity(name) {
+  return name.includes(".") ? toJsBindingIdent(name.replace(/\./g, "_")) : name;
+}
+function draftBindingName(identity, taken) {
+  if (isJsBindingIdent(identity) && !taken(identity)) return identity;
+  const alias = toJsBindingIdent(identity);
+  if (isJsBindingIdent(alias) && !taken(alias)) return alias;
+  let n = 1;
+  while (taken(`_nudo_${n}`)) n++;
+  return `_nudo_${n}`;
 }
-function draftExportName(name, used) {
-  return toJsBindingIdent(name.includes(".") ? name.replace(/\./g, "_") : name, used);
+function exportNameRepr(name) {
+  return /^(?:[$_\p{ID_Start}])(?:[$\u200C\u200D\p{ID_Continue}])*$/u.test(name) ? name : JSON.stringify(name);
+}
+function draftExportStmt(binding, identity, dsl) {
+  if (binding === identity) return [`export const ${binding} = ${dsl};`];
+  return [`const ${binding} = ${dsl};`, `export { ${binding} as ${exportNameRepr(identity)} };`];
 }
 function formatDtsContractDraft(label, files, exports) {
   const draftable = exports.filter((e) => e.dsl !== void 0);
@@ -1204,6 +3117,7 @@ function formatDtsContractDraft(label, files, exports) {
   }
   if (draftable.some((e) => /\bany\s*\(/.test(e.dsl))) used.add("any");
   const importList = BUILDERS.filter((b) => used.has(b)).join(", ");
+  const importNames = new Set(used);
   const exportUsed = /* @__PURE__ */ new Set();
   const lines = [
     "// @nudo:draft",
@@ -1231,7 +3145,12 @@ function formatDtsContractDraft(label, files, exports) {
     }
     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, exportUsed)} = ${e.dsl};`);
+    const identity = draftIdentity(e.name);
+    const binding = draftBindingName(identity, (n) => importNames.has(n) || exportUsed.has(n));
+    exportUsed.add(binding);
+    for (const stmt of draftExportStmt(binding, identity, e.dsl)) {
+      lines.push(stmt);
+    }
     if (e.name.includes(".")) {
       lines.push(`//   sidecar key may also be written as \`${e.name}\``);
     }
@@ -1239,14 +3158,20 @@ function formatDtsContractDraft(label, files, exports) {
   }
   return lines.join("\n");
 }
-function readDtsFiles(paths, maxFiles = 16) {
-  const out = [];
+var MAX_WALK_DEPTH = 6;
+function readDtsFiles(paths) {
+  const found = [];
+  let droppedDirs = 0;
   const walk = (dir, depth) => {
-    if (depth > 6 || out.length >= maxFiles * 3) return;
+    if (depth > MAX_WALK_DEPTH) {
+      droppedDirs++;
+      return;
+    }
     let entries;
     try {
       entries = readdirSync(dir);
     } catch {
+      droppedDirs++;
       return;
     }
     for (const name of entries) {
@@ -1256,71 +3181,183 @@ function readDtsFiles(paths, maxFiles = 16) {
       try {
         st = statSync2(p);
       } catch {
+        droppedDirs++;
         continue;
       }
       if (st.isDirectory()) walk(p, depth + 1);
-      else if (name.endsWith(".d.ts") && !name.endsWith(".d.ts.map")) out.push(p);
+      else if (name.endsWith(".d.ts") && !name.endsWith(".d.ts.map")) {
+        found.push(p);
+      }
+    }
+  };
+  for (const p of paths) {
+    const st = statSync2(p, { throwIfNoEntry: false });
+    if (st === void 0) continue;
+    if (st.isDirectory()) walk(p, 0);
+    else if (/\.d\.ts$/.test(p) || /\.(m)?ts$/.test(p)) {
+      if (!p.endsWith(".d.ts.map")) found.push(p);
+    }
+  }
+  found.sort();
+  return { files: found, droppedDirs };
+}
+function dtsToContractDraft(dtsFiles, label) {
+  const files = dtsFiles.filter((f) => existsSync(f));
+  const exports = [];
+  let skippedFiles = 0;
+  let droppedEntries = 0;
+  let lostEntries = 0;
+  for (const file of files) {
+    let content;
+    try {
+      content = readFileSync2(file, "utf8");
+    } catch {
+      skippedFiles++;
+      continue;
+    }
+    const sf = ts2.createSourceFile(file, content, ts2.ScriptTarget.Latest, true);
+    const collected = collectExports(sf);
+    lostEntries += collected.lost;
+    for (const e of collected.exports) {
+      if (exports.some((x) => x.name === e.name && x.dsl)) {
+        droppedEntries++;
+        continue;
+      }
+      exports.push(e);
+    }
+  }
+  const name = label ?? (files[0] ? basename(files[0]).replace(/\.d\.ts$/, "") : "dts");
+  const draftSource = formatDtsContractDraft(name, files, exports);
+  const unprojected = exports.filter((e) => e.dsl === void 0).length;
+  const partial = exports.filter((e) => e.partial && e.dsl !== void 0).length;
+  return {
+    label: name,
+    files,
+    exports,
+    draftSource,
+    stats: {
+      files: files.length - skippedFiles,
+      exports: exports.filter((e) => e.dsl !== void 0).length,
+      // skipped = 丢失的条数（整条没投影 + 投影了但有未建模部分 + 读失败 +
+      // 同名去重丢掉的 + 声明被合并掉的）——汇总行报「0 skipped」的前提是
+      // **真的**没丢东西
+      skipped: unprojected + partial + skippedFiles + droppedEntries + lostEntries
+    }
+  };
+}
+function dtsPathToContractDraft(path, label) {
+  const scan = readDtsFiles([path]);
+  const draft = dtsToContractDraft(scan.files, label ?? basename(path).replace(/\.d\.ts$/, ""));
+  if (scan.droppedDirs > 0) {
+    draft.stats.skipped += scan.droppedDirs;
+    draft.stats.droppedDirs = scan.droppedDirs;
+  }
+  return draft;
+}
+
+// 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 ts3 from "typescript";
+import { formatShape as formatShape2 } from "@nudojs/core";
+
+// src/lru-map.ts
+var BoundedLruMap = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  constructor(max) {
+    this.max = max;
+  }
+  get size() {
+    return this.map.size;
+  }
+  /** 当前上限（可动态收紧；收紧时立刻按 LRU 压到新上限） */
+  getMax() {
+    return this.max;
+  }
+  setMax(max) {
+    this.max = max;
+    this.trim();
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get(key) {
+    const hit = this.map.get(key);
+    if (hit === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, hit);
+    return hit;
+  }
+  /** 命中不改变 LRU 序（只读探测） */
+  peek(key) {
+    return this.map.get(key);
+  }
+  set(key, value) {
+    if (this.max <= 0) return;
+    while (this.map.size >= this.max && !this.map.has(key)) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
     }
-  };
-  for (const p of paths) {
-    const st = statSync2(p, { throwIfNoEntry: false });
-    if (st === void 0) continue;
-    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);
+    this.map.delete(key);
+    this.map.set(key, value);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  values() {
+    return this.map.values();
+  }
+  entries() {
+    return this.map.entries();
+  }
+  /** 压到当前 max（调低上限时收内存） */
+  trim() {
+    while (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
     }
   }
-  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;
+};
+
+// src/harvest-package.ts
+function packageDeclaresTypes(root) {
+  const pj = join2(root, "package.json");
+  if (existsSync2(pj)) {
     try {
-      content = readFileSync2(file, "utf8");
+      const raw = JSON.parse(readFileSync3(pj, "utf8"));
+      const entry = raw.types ?? raw.typings;
+      if (typeof entry === "string" && entry.length > 0 && existsSync2(resolve(root, entry))) {
+        return true;
+      }
     } catch {
-      skippedFiles++;
-      continue;
-    }
-    const sf = ts2.createSourceFile(file, content, ts2.ScriptTarget.Latest, true);
-    for (const e of collectExports(sf)) {
-      if (exports.some((x) => x.name === e.name && x.dsl)) continue;
-      exports.push(e);
     }
   }
-  const name = label ?? (files[0] ? basename(files[0]).replace(/\.d\.ts$/, "") : "dts");
-  const draftSource = formatDtsContractDraft(name, files, exports);
-  return {
-    label: name,
-    files,
-    exports,
-    draftSource,
-    stats: {
-      files: files.length - skippedFiles,
-      exports: exports.filter((e) => e.dsl !== void 0).length,
-      skipped: exports.filter((e) => e.dsl === void 0).length + skippedFiles
-    }
-  };
-}
-function dtsPathToContractDraft(path, label) {
-  const files = readDtsFiles([path]);
-  return dtsToContractDraft(files, label ?? basename(path).replace(/\.d\.ts$/, ""));
+  return existsSync2(join2(root, "index.d.ts"));
 }
-
-// src/harvest-package.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join2, resolve, dirname as dirname2, basename as basename2 } from "path";
-import { formatShape as formatShape2 } from "@nudojs/core";
 function resolvePackageRoot(pkg, fromDir = process.cwd()) {
-  let dir = resolve(fromDir);
   const bare = pkg.replace(/^@/, "").replace(/\//g, "__");
+  const start = resolve(fromDir);
+  let dir = start;
+  for (let i = 0; i < 8; i++) {
+    const pkgPath = join2(dir, "node_modules", pkg);
+    if (existsSync2(pkgPath) && packageDeclaresTypes(pkgPath)) return pkgPath;
+    const parent = resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  dir = start;
   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;
@@ -1435,9 +3472,170 @@ function harvestPackage(pkg, fromDir, maxFiles = 24) {
   const env = harvestDts(dtsFiles);
   return { pkg, root, dtsFiles, env };
 }
+function topLevelNames(stmt) {
+  if (ts3.isFunctionDeclaration(stmt) || ts3.isClassDeclaration(stmt)) {
+    return stmt.name ? [stmt.name.text] : [];
+  }
+  if (ts3.isInterfaceDeclaration(stmt) || ts3.isTypeAliasDeclaration(stmt)) {
+    return [stmt.name.text];
+  }
+  if (ts3.isEnumDeclaration(stmt)) return [stmt.name.text];
+  if (ts3.isModuleDeclaration(stmt)) {
+    return ts3.isIdentifier(stmt.name) ? [stmt.name.text] : [];
+  }
+  if (ts3.isVariableStatement(stmt)) {
+    const names = [];
+    for (const decl of stmt.declarationList.declarations) {
+      if (ts3.isIdentifier(decl.name)) names.push(decl.name.text);
+    }
+    return names;
+  }
+  return [];
+}
+function ambientNames(stmt) {
+  const names = [];
+  if (!stmt.body || !ts3.isModuleBlock(stmt.body)) return names;
+  for (const inner of stmt.body.statements) names.push(...topLevelNames(inner));
+  return names;
+}
+function modifierKinds(stmt) {
+  if (!ts3.canHaveModifiers(stmt)) return [];
+  return (ts3.getModifiers(stmt) ?? []).map((m) => m.kind);
+}
+function emptyScan() {
+  return {
+    exported: /* @__PURE__ */ new Set(),
+    ambient: /* @__PURE__ */ new Set(),
+    stars: [],
+    isModule: false
+  };
+}
+function scanDtsFile(file) {
+  let content;
+  try {
+    content = readFileSync3(file, "utf8");
+  } catch {
+    return emptyScan();
+  }
+  let sf;
+  try {
+    sf = ts3.createSourceFile(file, content, ts3.ScriptTarget.Latest, true);
+  } catch {
+    return emptyScan();
+  }
+  const scan = {
+    exported: /* @__PURE__ */ new Set(),
+    ambient: /* @__PURE__ */ new Set(),
+    stars: [],
+    isModule: ts3.isExternalModule(sf)
+  };
+  for (const stmt of sf.statements) {
+    if (ts3.isModuleDeclaration(stmt)) {
+      if (ts3.isIdentifier(stmt.name) && stmt.name.text === "global") {
+        for (const n of ambientNames(stmt)) scan.ambient.add(n);
+      }
+      continue;
+    }
+    if (ts3.isExportDeclaration(stmt)) {
+      const clause = stmt.exportClause;
+      if (!clause) {
+        if (stmt.moduleSpecifier && ts3.isStringLiteral(stmt.moduleSpecifier)) {
+          scan.stars.push(stmt.moduleSpecifier.text);
+        }
+        continue;
+      }
+      if (ts3.isNamespaceExport(clause)) {
+        scan.exported.add(clause.name.text);
+        continue;
+      }
+      for (const el of clause.elements) scan.exported.add(el.name.text);
+      continue;
+    }
+    if (ts3.isExportAssignment(stmt)) {
+      scan.exported.add("default");
+      continue;
+    }
+    const names = topLevelNames(stmt);
+    const mods = modifierKinds(stmt);
+    if (mods.includes(ts3.SyntaxKind.DefaultKeyword)) {
+      scan.exported.add("default");
+      continue;
+    }
+    const isExported2 = mods.includes(ts3.SyntaxKind.ExportKeyword);
+    for (const n of names) {
+      if (isExported2) scan.exported.add(n);
+      else if (!scan.isModule) scan.ambient.add(n);
+    }
+  }
+  return scan;
+}
+var fileScanCache = new BoundedLruMap(64);
+function dtsFileScan(file) {
+  const hit = fileScanCache.get(file);
+  if (hit) return hit;
+  const scan = scanDtsFile(file);
+  fileScanCache.set(file, scan);
+  return scan;
+}
+function resolveStarTarget(spec, fromFile) {
+  if (!spec.startsWith(".")) return void 0;
+  const raw = resolve(dirname2(fromFile), spec);
+  const stem = raw.replace(/\.(js|mjs|cjs|ts)$/, "");
+  for (const cand of [`${raw}.d.ts`, `${stem}.d.ts`, join2(raw, "index.d.ts"), join2(stem, "index.d.ts")]) {
+    if (existsSync2(cand)) return cand;
+  }
+  return void 0;
+}
+function packageEntryFile(h) {
+  const entry = entryDtsFromPackageJson(h.root) ?? join2(h.root, "index.d.ts");
+  if (existsSync2(entry)) return entry;
+  return h.dtsFiles[0];
+}
+var surfaceCache = /* @__PURE__ */ new WeakMap();
+function packageExportSurface(h) {
+  const hit = surfaceCache.get(h);
+  if (hit) return hit;
+  const names = /* @__PURE__ */ new Set();
+  let unresolved = false;
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (file) => {
+    if (visited.has(file)) return;
+    visited.add(file);
+    const scan = dtsFileScan(file);
+    for (const n of scan.exported) names.add(n);
+    for (const spec of scan.stars) {
+      const target = resolveStarTarget(spec, file);
+      if (target) visit(target);
+      else unresolved = true;
+    }
+  };
+  const entry = packageEntryFile(h);
+  if (entry) visit(entry);
+  const surface = { names, unresolved };
+  surfaceCache.set(h, surface);
+  return surface;
+}
+function packageAmbientNames(h) {
+  const ambient = /* @__PURE__ */ new Set();
+  for (const file of h.dtsFiles) {
+    for (const n of dtsFileScan(file).ambient) ambient.add(n);
+  }
+  return ambient;
+}
+function resolveSubpathEntry(root, sub) {
+  if (!sub) return void 0;
+  const base = resolve(root, sub);
+  for (const cand of [`${base}.d.ts`, join2(base, "index.d.ts")]) {
+    if (existsSync2(cand)) return cand;
+  }
+  return void 0;
+}
 function formatHarvestSummary(h) {
   const lines = [];
-  lines.push(`${h.pkg}: ${h.dtsFiles.length} d.ts, ${h.env.stats.symbols} symbols`);
+  const degraded = h.env.stats.degraded ?? 0;
+  lines.push(
+    `${h.pkg}: ${h.dtsFiles.length} d.ts, ${h.env.stats.symbols} symbols` + (degraded > 0 ? `, ${degraded} degraded` : "")
+  );
   const mods = Object.keys(h.env.modules);
   for (const m of mods.slice(0, 5)) {
     const exports = h.env.modules[m];
@@ -1513,7 +3711,10 @@ import {
   relationFn as relationFn2,
   getFnImpl as getFnImpl2
 } from "@nudojs/core";
-var HARVEST_DISK_ABI = "nudo-harvest-disk-v8";
+function nullDict2() {
+  return /* @__PURE__ */ Object.create(null);
+}
+var HARVEST_DISK_ABI = "nudo-harvest-disk-v11";
 function sha256Hex(data) {
   return createHash("sha256").update(data).digest("hex");
 }
@@ -1541,27 +3742,44 @@ function absToHarvestSig(a) {
     case "arr":
       return { k: "arr", element: absToHarvestSig(s.element) };
     case "tuple":
-      return { k: "tuple", elements: s.elements.map(absToHarvestSig) };
+      return {
+        k: "tuple",
+        elements: s.elements.map(absToHarvestSig),
+        ...s.rest ? { rest: absToHarvestSig(s.rest) } : {}
+      };
     case "obj": {
-      const slots = {};
+      const slots = nullDict2();
       for (const [key, slot] of Object.entries(s.slots)) {
         slots[key] = {
           v: absToHarvestSig(slot.value),
           ...slot.optional ? { opt: true } : {}
         };
       }
-      return { k: "obj", slots };
+      return {
+        k: "obj",
+        slots,
+        ...s.index ? { index: { key: absToHarvestSig(s.index.key), value: absToHarvestSig(s.index.value) } } : {},
+        ...s.open ? { open: true } : {}
+      };
     }
     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" };
+      const fnSlots = nullDict2();
+      for (const [key, slot] of Object.entries(s.slots ?? {})) {
+        fnSlots[key] = absToHarvestSig(slot.value);
+      }
       return {
         k: "fn",
         params: s.params,
         paramTypes,
-        returns: absToHarvestSig(retSrc)
+        returns: absToHarvestSig(retSrc),
+        ...s.ctor !== void 0 ? { ctor: s.ctor } : {},
+        ...Object.keys(fnSlots).length > 0 ? { slots: fnSlots } : {},
+        ...rel?.inferFrom ? { inferFrom: rel.inferFrom } : {},
+        ...rel?.condFallback ? { condFallback: absToHarvestSig(rel.condFallback) } : {}
       };
     }
     case "sum":
@@ -1583,15 +3801,13 @@ function harvestSigToAbs(sig) {
     return a;
   };
   switch (sig.k) {
-    case "prim":
-      return mark(
-        abs(
-          { k: "prim", type: sig.type },
-          void 0,
-          void 0,
-          "mock"
-        )
-      );
+    case "prim": {
+      const t = sig.type;
+      if (t !== "number" && t !== "string" && t !== "boolean" && t !== "bigint" && t !== "symbol") {
+        return mark(abs({ k: "unknown" }, void 0, void 0, "mock"));
+      }
+      return mark(abs({ k: "prim", type: t }, void 0, void 0, "mock"));
+    }
     case "unknown":
       return mark(abs({ k: "unknown" }, void 0, void 0, "mock"));
     case "any":
@@ -1618,29 +3834,65 @@ function harvestSigToAbs(sig) {
       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")
+        abs(
+          {
+            k: "tuple",
+            elements: sig.elements.map(harvestSigToAbs),
+            ...sig.rest ? { rest: harvestSigToAbs(sig.rest) } : {}
+          },
+          void 0,
+          void 0,
+          "mock"
+        )
       );
     case "obj": {
-      const slots = {};
+      const slots = nullDict2();
       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"));
+      return mark(
+        abs(
+          {
+            k: "obj",
+            slots,
+            ...sig.index ? { index: { key: harvestSigToAbs(sig.index.key), value: harvestSigToAbs(sig.index.value) } } : {},
+            ...sig.open ? { open: true } : {}
+          },
+          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"
-        })
-      );
+      const fn = relationFn2(paramTypes, returnType, {
+        params: sig.params,
+        conf: "mock",
+        // 族 27 Bug 821 残留：条件元数据必须一起往返，否则缓存命中后
+        // `infer` 绑定与假支丢失 ⇒ 冷/热缓存结论不一致。
+        ...sig.inferFrom ? { inferFrom: sig.inferFrom } : {},
+        ...sig.condFallback ? { condFallback: harvestSigToAbs(sig.condFallback) } : {}
+      });
+      const fnShape = fn.shape;
+      if (fnShape.k === "fn") {
+        const fnSlots = nullDict2();
+        for (const [key, v] of Object.entries(sig.slots ?? {})) {
+          fnSlots[key] = { value: harvestSigToAbs(v) };
+        }
+        fn.shape = {
+          ...fnShape,
+          ...sig.ctor !== void 0 ? { ctor: sig.ctor } : {},
+          ...Object.keys(fnSlots).length > 0 ? { slots: fnSlots } : {}
+        };
+      }
+      return mark(fn);
     }
     case "sum":
       return mark(
@@ -1674,13 +3926,13 @@ function harvestSigToAbs(sig) {
   }
 }
 function serializeHarvestJson(pkg, env, meta) {
-  const modules = {};
+  const modules = nullDict2();
   for (const [mod, rec] of Object.entries(env.modules)) {
-    const named = {};
+    const named = nullDict2();
     for (const [k, v] of Object.entries(rec)) named[k] = absToHarvestSig(v);
     modules[mod] = named;
   }
-  const globals = {};
+  const globals = nullDict2();
   for (const [k, v] of Object.entries(env.globals)) globals[k] = absToHarvestSig(v);
   return {
     v: 1,
@@ -1700,13 +3952,13 @@ function materializeHarvestJson(j) {
   if (h.knobs?.abi !== HARVEST_DISK_ABI) return null;
   if (!h.modules || typeof h.modules !== "object") return null;
   try {
-    const modules = {};
+    const modules = nullDict2();
     for (const [mod, rec] of Object.entries(h.modules)) {
-      const named = {};
+      const named = nullDict2();
       for (const [k, sig] of Object.entries(rec)) named[k] = harvestSigToAbs(sig);
       modules[mod] = named;
     }
-    const globals = {};
+    const globals = nullDict2();
     for (const [k, sig] of Object.entries(h.globals ?? {})) {
       globals[k] = harvestSigToAbs(sig);
     }
@@ -1850,73 +4102,6 @@ function loadHarvestEnvFromDisk(pkg, meta) {
   return hit ? materializeHarvestJson(hit) : null;
 }
 
-// src/lru-map.ts
-var BoundedLruMap = class {
-  map = /* @__PURE__ */ new Map();
-  max;
-  constructor(max) {
-    this.max = max;
-  }
-  get size() {
-    return this.map.size;
-  }
-  /** 当前上限（可动态收紧；收紧时立刻按 LRU 压到新上限） */
-  getMax() {
-    return this.max;
-  }
-  setMax(max) {
-    this.max = max;
-    this.trim();
-  }
-  has(key) {
-    return this.map.has(key);
-  }
-  get(key) {
-    const hit = this.map.get(key);
-    if (hit === void 0) return void 0;
-    this.map.delete(key);
-    this.map.set(key, hit);
-    return hit;
-  }
-  /** 命中不改变 LRU 序（只读探测） */
-  peek(key) {
-    return this.map.get(key);
-  }
-  set(key, value) {
-    if (this.max <= 0) return;
-    while (this.map.size >= this.max && !this.map.has(key)) {
-      const oldest = this.map.keys().next().value;
-      if (oldest === void 0) break;
-      this.map.delete(oldest);
-    }
-    this.map.delete(key);
-    this.map.set(key, value);
-  }
-  delete(key) {
-    return this.map.delete(key);
-  }
-  clear() {
-    this.map.clear();
-  }
-  keys() {
-    return this.map.keys();
-  }
-  values() {
-    return this.map.values();
-  }
-  entries() {
-    return this.map.entries();
-  }
-  /** 压到当前 max（调低上限时收内存） */
-  trim() {
-    while (this.map.size > this.max) {
-      const oldest = this.map.keys().next().value;
-      if (oldest === void 0) break;
-      this.map.delete(oldest);
-    }
-  }
-};
-
 // src/harvest-auto.ts
 var NODE_BUILTINS = /* @__PURE__ */ new Set([
   "assert",
@@ -2048,17 +4233,22 @@ function harvestedValueToAbs(a) {
       body: [],
       directives: []
     };
+    const ctor = a.shape.ctor;
     return markMockConf(
-      absFunction(params, {
-        body: dummyBody,
-        apply: (args) => {
-          if (relation) {
-            return markMockConf(instantiateReturn(a, args));
-          }
-          return markMockConf({ ...ret });
+      absFunction(
+        params,
+        {
+          body: dummyBody,
+          apply: (args) => {
+            if (relation) {
+              return markMockConf(instantiateReturn(a, args));
+            }
+            return markMockConf({ ...ret });
+          },
+          ...relation ? { relation } : {}
         },
-        ...relation ? { relation } : {}
-      })
+        ctor !== void 0 ? { ctor } : void 0
+      )
     );
   }
   return markMockConf({ ...a });
@@ -2078,7 +4268,7 @@ function packageHarvestToAbsModules(pkg, h) {
     return named;
   };
   const register = (key, exports) => {
-    if (!out[key]) out[key] = exports;
+    if (!Object.hasOwn(out, key)) out[key] = exports;
   };
   for (const [mod, rec] of Object.entries(h.env.modules)) {
     const named = convertRecord(rec);
@@ -2086,22 +4276,63 @@ function packageHarvestToAbsModules(pkg, h) {
     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);
+    if (stripped && stripped !== pkg) 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 };
+  out[pkg] = packageRootExports(pkg, h);
+  return out;
+}
+function packageRootExports(pkg, h) {
+  const globals = h.env.globals;
+  const surface = packageExportSurface(h);
+  const named = {};
+  if (surface.unresolved) {
+    const ambient = packageAmbientNames(h);
+    for (const [k, v] of Object.entries(globals)) {
+      if (ambient.has(k)) continue;
+      named[k] = harvestedValueToAbs(v);
+    }
+  } else {
+    for (const n of surface.names) {
+      if (!Object.hasOwn(globals, n)) continue;
+      named[n] = harvestedValueToAbs(globals[n]);
     }
   }
-  return out;
+  const exports = { named };
+  if (surface.unresolved || surface.names.has("default")) {
+    const def = Object.hasOwn(globals, "default") ? globals["default"] : void 0;
+    if (def) exports.default = harvestedValueToAbs(def);
+  }
+  const aug = Object.hasOwn(h.env.modules, pkg) ? h.env.modules[pkg] : void 0;
+  if (aug) {
+    for (const [k, v] of Object.entries(aug)) {
+      if (Object.hasOwn(named, k)) continue;
+      named[k] = harvestedValueToAbs(v);
+    }
+  }
+  return exports;
+}
+var subpathCache = new BoundedLruMap(32);
+function subpathExports(pkg, spec, h) {
+  const sub = spec.slice(pkg.length + 1);
+  const file = resolveSubpathEntry(h.root, sub);
+  if (!file) return void 0;
+  const hit = subpathCache.get(file);
+  if (hit) return hit;
+  const env = harvestDts([file]);
+  const scan = dtsFileScan(file);
+  const named = {};
+  for (const n of scan.exported) {
+    if (!Object.hasOwn(env.globals, n)) continue;
+    named[n] = harvestedValueToAbs(env.globals[n]);
+  }
+  const exports = { named };
+  const def = Object.hasOwn(env.globals, "default") ? env.globals["default"] : void 0;
+  if (def) exports.default = harvestedValueToAbs(def);
+  subpathCache.set(file, exports);
+  return exports;
 }
 function bareSpecToAbsModules(spec, fromFile) {
   if (!spec || spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("node:")) {
@@ -2110,8 +4341,12 @@ function bareSpecToAbsModules(spec, fromFile) {
   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];
+  const h = harvestPackageCached(pkg, dirname4(fromFile));
+  if (!h) return void 0;
+  const table = packageHarvestToAbsModules(pkg, h);
+  if (spec === pkg) return table[pkg];
+  if (Object.hasOwn(table, spec)) return table[spec];
+  return subpathExports(pkg, spec, h);
 }
 
 // src/harvest-node.ts
@@ -2242,7 +4477,8 @@ function harvestNodeTypes(fromDir, maxFiles = HARVEST_NODE_DEFAULT_MAX_FILES, ma
       const stats = {
         files: env.stats.files,
         symbols: env.stats.symbols,
-        skipped: env.stats.skipped
+        skipped: env.stats.skipped,
+        ...env.stats.degraded !== void 0 ? { degraded: env.stats.degraded } : {}
       };
       const result = {
         ok: true,
@@ -2261,7 +4497,8 @@ function harvestNodeTypes(fromDir, maxFiles = HARVEST_NODE_DEFAULT_MAX_FILES, ma
     const stats = {
       files: env.stats.files,
       symbols: env.stats.symbols,
-      skipped: env.stats.skipped
+      skipped: env.stats.skipped,
+      ...env.stats.degraded !== void 0 ? { degraded: env.stats.degraded } : {}
     };
     if (diskRoot) {
       writeHarvestDisk(