@nudojs/core 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,6 +1,8 @@
 import {
   $add,
   $arr,
+  $arrMutContainer,
+  $arrRest,
   $async,
   $asyncReturn,
   $await,
@@ -12,6 +14,7 @@ import {
   $div,
   $elems,
   $eq,
+  $eqLoose,
   $fnVal,
   $for,
   $forIter,
@@ -25,22 +28,29 @@ import {
   $idxSet,
   $invoke,
   $invokeSuper,
+  $isForkExit,
   $join,
   $le,
   $len,
   $lit,
+  $loopReturn,
   $lt,
   $mod,
   $mul,
   $ne,
+  $neLoose,
   $neg,
   $new,
   $not,
+  $nullishTest,
   $obj,
+  $objRest,
   $optionalGet,
   $optionalInvoke,
   $orDefault,
+  $pushLoopExit,
   $regex,
+  $rethrowIfNudoReturn,
   $set,
   $setKey,
   $spread,
@@ -51,6 +61,10 @@ import {
   $thisGet,
   $thisSet,
   $throw,
+  $tryCurrentMark,
+  $tryMark,
+  $tryPopMark,
+  $tryTakeSince,
   $typeof,
   $while,
   $whileSeq,
@@ -58,15 +72,19 @@ import {
   DEFAULT_MAX_LOOP_ITERS,
   MAX_CALL_DEPTH,
   MAX_TOTAL_CALLS,
+  NudoReturn,
   NudoThrow,
+  abortDerivationSession,
   abs,
   absFunction,
+  absShapeKey,
   absTemplateViews,
   absToString,
   add,
   allFixedTextOfViews,
   alphaOf,
   analyzeFn,
+  analyzeFnFull,
   and,
   anyVar,
   app,
@@ -76,20 +94,27 @@ import {
   asAbsVal,
   attachFnImpl,
   awaitAbs,
+  beginCollectionFork,
+  beginDerivationSession,
   betaOf,
   bindImports,
   bool,
   boolLit,
   callAbsMethod,
+  callAtFunctionBoundary,
   callFunction,
+  callFunctionFull,
   callTranspiledExport,
   callTranspiledExportFull,
   classFromMethods,
   clearBClasses,
+  clearCollectionTables,
   cmp,
   coerceAsyncReturn,
   collectAbsExports,
   collectAbsNodeTypes,
+  collectionElementJoin,
+  collectionExactLen,
   concatString,
   confJoin,
   createHofCollectCtx,
@@ -101,10 +126,14 @@ import {
   defaultLeakBudget,
   defineClass,
   definitelyNotNullishShape,
+  derivationChain,
   div,
   emptyEnv,
   emptyPhi,
+  endCollectionFork,
+  endDerivationSession,
   eq,
+  errorBrandAbs,
   evalArrayStatic,
   evalBuiltinInstanceMethod,
   evalBuiltinNew,
@@ -139,23 +168,31 @@ import {
   getBClass,
   getClass,
   getClassChain,
+  getDerivation,
   getFnImpl,
   getParseSourceCacheSize,
   getSlot,
   gt,
   gtNum,
+  hasDerivationSession,
   implies,
   instanceOf,
   instantiateClass,
   instantiateReturn,
+  isArrMutator,
   isDefinitelyFalse,
   isDefinitelyTrue,
+  isErrorCtorName,
+  isEvalMissingSlotEnabled,
   isExactLit,
+  isMapAbs,
+  isNudoReturn,
   isNudoThrow,
   isNullishLitAbs,
   isNumPrim,
   isObj,
   isRelFn,
+  isSetAbs,
   isStrPrim,
   isTemplateLike,
   joinAbs,
@@ -174,13 +211,25 @@ import {
   lookupMethod,
   lookupMethodWithOwner,
   lookupSuperMethod,
+  looseEqAbs,
   lt,
   ltNum,
+  makeMapAbs,
+  makeSetAbs,
   makeSum,
+  mapClearEntries,
+  mapDeleteEntry,
   mapElementFallback,
+  mapEntriesAbs,
+  mapGetEntry,
+  mapHasEntry,
+  mapSetEntry,
+  mapSizeAbs,
+  mapValuesAbs,
   matchRelIdentLit,
   maybeLeak,
   mergeAdjacentFixedViews,
+  mergeCollectionArms,
   mod,
   mul,
   namespaceNameOf,
@@ -189,7 +238,11 @@ import {
   never,
   not,
   notAbs,
+  noteCollectionWrite,
+  noteDerivationAdd,
+  noteDerivationJoin,
   noteMemberDispatchMiss,
+  noteObjSlotMissing,
   notePrimMemberMissing,
   noteUnknownMemberMissing,
   num,
@@ -202,13 +255,18 @@ import {
   pTrue,
   parseSource,
   phiAnd,
+  popCollectionArm,
   predEquals,
   predToString,
   predVars,
   projectBrand,
+  projectDerivationDsl,
   projectFlatMapResult,
   promoteParamShape,
   ptypeof,
+  pushCollectionArm,
+  pushLoopExit,
+  pushThrowExit,
   recordMemberDiag,
   refineAbsForRelTrue,
   registerBClass,
@@ -218,13 +276,24 @@ import {
   resetLeakCounter,
   resetParseSourceCache,
   runTranspiled,
+  runWithEvalMissingSlot,
+  runWithLoopExits,
   setAbsAssignCollector,
   setAbsCallCollector,
   setAbsNodeCollector,
   setAbsTruncationCollector,
+  setAddEntry,
   setApplyCallbackHost,
   setBCallCollector,
+  setClearEntries,
+  setDeleteEntry,
+  setDerivation,
+  setDerivationCollector,
+  setElementsAbs,
+  setEvalMissingSlotEnabled,
+  setHasEntry,
   setMemberDiagCollector,
+  setSizeAbs,
   shapeOfTerm,
   shapeOnlyFn,
   shapeToString,
@@ -241,10 +310,14 @@ import {
   substPredAbs,
   superNameOf,
   tagAbsOrigin,
+  tagDerivationRoot,
+  takeLoopExits,
+  takeThrowExits,
   templateMatchesValue,
   templatePartsOf,
   termDepth,
   termEquals,
+  termKey,
   termNodes,
   termToString,
   transpile,
@@ -264,711 +337,7 @@ import {
   withExecPhi,
   withVar,
   wrapPromise
-} from "./chunk-RZOQL6PT.js";
-
-// src/refinements/template-predicates.ts
-function isTemplate(tv) {
-  return tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts);
-}
-
-// src/type-value.ts
-function createUnion(...members) {
-  return simplifyUnion(members);
-}
-var T = {
-  literal: (value) => ({ kind: "literal", value }),
-  number: { kind: "primitive", type: "number" },
-  string: { kind: "primitive", type: "string" },
-  boolean: { kind: "primitive", type: "boolean" },
-  bigint: { kind: "primitive", type: "bigint" },
-  symbol: { kind: "primitive", type: "symbol" },
-  null: { kind: "literal", value: null },
-  undefined: { kind: "literal", value: void 0 },
-  unknown: { kind: "unknown" },
-  never: { kind: "never" },
-  object: (properties) => ({
-    kind: "object",
-    properties,
-    id: Symbol("object")
-  }),
-  array: (element) => ({ kind: "array", element }),
-  tuple: (elements) => ({ kind: "tuple", elements }),
-  promise: (value) => ({ kind: "promise", value }),
-  instanceOf: (className, properties = {}) => ({
-    kind: "instance",
-    className,
-    properties
-  }),
-  union: createUnion,
-  fn: (params, body, closure) => ({
-    kind: "function",
-    params,
-    body,
-    closure
-  }),
-  refine: (base, refinement) => ({
-    kind: "refined",
-    base,
-    refinement
-  }),
-  fnSig: (paramTypes, returnType, throwsType = { kind: "never" }, impl) => {
-    const dummy = {
-      kind: "function",
-      params: paramTypes.map((_p, i) => `_arg${i}`),
-      body: { type: "BlockStatement", body: [], directives: [] },
-      closure: null
-    };
-    dummy._signature = { paramTypes, returnType, throwsType, impl };
-    return dummy;
-  }
-};
-function typeValueEquals(a, b) {
-  if (a.kind !== b.kind) return false;
-  if (a.kind === "literal" && b.kind === "literal") return a.value === b.value;
-  if (a.kind === "primitive" && b.kind === "primitive") return a.type === b.type;
-  if (a.kind === "never" && b.kind === "never") return true;
-  if (a.kind === "unknown" && b.kind === "unknown") return true;
-  if (a.kind === "refined" && b.kind === "refined") {
-    return a.refinement.name === b.refinement.name && typeValueEquals(a.base, b.base);
-  }
-  if (a.kind === "promise" && b.kind === "promise") {
-    return typeValueEquals(a.value, b.value);
-  }
-  if (a.kind === "instance" && b.kind === "instance") {
-    return a.className === b.className;
-  }
-  if (a.kind === "union" && b.kind === "union") {
-    return a.members.length === b.members.length && a.members.every((m, i) => typeValueEquals(m, b.members[i]));
-  }
-  return a === b;
-}
-function simplifyUnion(members) {
-  if (members.length === 0) return T.never;
-  if (members.length === 1) return members[0].kind === "never" ? T.never : members[0];
-  if (members.length === 2) {
-    const a = members[0];
-    const b = members[1];
-    if (a.kind !== "union" && b.kind !== "union") {
-      if (a.kind === "never") return b.kind === "never" ? T.never : b;
-      if (b.kind === "never") return a;
-      if (typeValueEquals(a, b)) return a;
-      if (a.kind === "unknown" || b.kind === "unknown") return T.unknown;
-      const aBase = absorbablePrimitiveBase(a);
-      if (aBase !== void 0 && typeValueEquals(aBase, b)) return b;
-      const bBase = absorbablePrimitiveBase(b);
-      if (bBase !== void 0 && typeValueEquals(bBase, a)) return a;
-      return { kind: "union", members: [a, b] };
-    }
-  }
-  const flat = [];
-  for (const m of members) {
-    if (m.kind === "never") continue;
-    if (m.kind === "union") {
-      flat.push(...m.members);
-    } else {
-      flat.push(m);
-    }
-  }
-  const deduped = [];
-  for (const m of flat) {
-    if (!deduped.some((d) => typeValueEquals(d, m))) {
-      deduped.push(m);
-    }
-  }
-  const primitives = deduped.filter((m) => m.kind === "primitive");
-  const absorbed = primitives.length > 0 ? deduped.filter((m) => {
-    const base = absorbablePrimitiveBase(m);
-    return base === void 0 || !primitives.some((p) => typeValueEquals(p, base));
-  }) : deduped;
-  if (absorbed.length === 0) return T.never;
-  if (absorbed.length === 1) return absorbed[0];
-  if (absorbed.some((m) => m.kind === "unknown")) return T.unknown;
-  return { kind: "union", members: absorbed };
-}
-function absorbablePrimitiveBase(tv) {
-  if (tv.kind === "literal") {
-    const widened = widenLiteral(tv);
-    return widened.kind === "primitive" ? widened : void 0;
-  }
-  if (isTemplate(tv)) return T.string;
-  return void 0;
-}
-function widenLiteral(tv) {
-  if (tv.kind !== "literal") return tv;
-  const v2 = tv.value;
-  if (typeof v2 === "number") return T.number;
-  if (typeof v2 === "string") return T.string;
-  if (typeof v2 === "boolean") return T.boolean;
-  if (typeof v2 === "bigint") return T.bigint;
-  if (v2 === null) return T.null;
-  if (v2 === void 0) return T.undefined;
-  return T.unknown;
-}
-function collapseLiteralUnion(tv, maxLiterals) {
-  if (tv.kind !== "union") return tv;
-  if (tv.members.length <= maxLiterals) return tv;
-  const simplified = simplifyUnion(tv.members);
-  if (simplified.kind !== "union") return simplified;
-  if (!simplified.members.every((m) => m.kind === "literal")) return simplified;
-  const first = widenLiteral(simplified.members[0]);
-  if (!simplified.members.every((m) => typeValueEquals(widenLiteral(m), first))) return simplified;
-  return first;
-}
-function isSubtypeOf(a, b) {
-  if (b.kind === "unknown") return true;
-  if (a.kind === "never") return true;
-  if (typeValueEquals(a, b)) return true;
-  if (a.kind === "literal" && b.kind === "primitive") {
-    const v2 = a.value;
-    if (b.type === "number" && typeof v2 === "number") return true;
-    if (b.type === "string" && typeof v2 === "string") return true;
-    if (b.type === "boolean" && typeof v2 === "boolean") return true;
-    return false;
-  }
-  if (a.kind === "literal" && b.kind === "refined") {
-    if (!isSubtypeOf(a, b.base)) return false;
-    return b.refinement.check ? b.refinement.check(a.value) : false;
-  }
-  if (a.kind === "refined") {
-    if (b.kind === "refined" && a.refinement.name === b.refinement.name) {
-      return isSubtypeOf(a.base, b.base);
-    }
-    return isSubtypeOf(a.base, b);
-  }
-  if (a.kind === "object" && b.kind === "object") {
-    return Object.entries(b.properties).every(
-      ([k, bv]) => k in a.properties && isSubtypeOf(a.properties[k], bv)
-    );
-  }
-  if (a.kind === "array" && b.kind === "array") {
-    return isSubtypeOf(a.element, b.element);
-  }
-  if (a.kind === "tuple" && b.kind === "tuple") {
-    return a.elements.length === b.elements.length && a.elements.every((el, i) => isSubtypeOf(el, b.elements[i]));
-  }
-  if (a.kind === "tuple" && b.kind === "array") {
-    return a.elements.every((el) => isSubtypeOf(el, b.element));
-  }
-  if (a.kind === "promise" && b.kind === "promise") {
-    return isSubtypeOf(a.value, b.value);
-  }
-  if (a.kind === "instance" && b.kind === "instance") {
-    return a.className === b.className || isErrorSubclass(a.className, b.className);
-  }
-  if (a.kind === "union") {
-    return a.members.every((m) => isSubtypeOf(m, b));
-  }
-  if (b.kind === "union") {
-    return b.members.some((m) => isSubtypeOf(a, m));
-  }
-  return false;
-}
-var errorHierarchy = {
-  TypeError: "Error",
-  SyntaxError: "Error",
-  RangeError: "Error",
-  ReferenceError: "Error",
-  URIError: "Error",
-  EvalError: "Error"
-};
-function isErrorSubclass(child, parent) {
-  if (child === parent) return true;
-  const sup = errorHierarchy[child];
-  return sup ? isErrorSubclass(sup, parent) : false;
-}
-function deepCloneTypeValue(tv, idMap) {
-  const map = idMap ?? /* @__PURE__ */ new Map();
-  if (tv.kind === "object") {
-    let newId = map.get(tv.id);
-    if (!newId) {
-      newId = Symbol("object");
-      map.set(tv.id, newId);
-    }
-    const newProps = {};
-    for (const [k, v2] of Object.entries(tv.properties)) {
-      newProps[k] = deepCloneTypeValue(v2, map);
-    }
-    return { kind: "object", properties: newProps, id: newId };
-  }
-  if (tv.kind === "array") {
-    return { kind: "array", element: deepCloneTypeValue(tv.element, map) };
-  }
-  if (tv.kind === "tuple") {
-    return { kind: "tuple", elements: tv.elements.map((e) => deepCloneTypeValue(e, map)) };
-  }
-  if (tv.kind === "promise") {
-    return { kind: "promise", value: deepCloneTypeValue(tv.value, map) };
-  }
-  if (tv.kind === "instance") {
-    const newProps = {};
-    for (const [k, v2] of Object.entries(tv.properties)) {
-      newProps[k] = deepCloneTypeValue(v2, map);
-    }
-    return { kind: "instance", className: tv.className, properties: newProps };
-  }
-  if (tv.kind === "refined") {
-    return { kind: "refined", base: deepCloneTypeValue(tv.base, map), refinement: tv.refinement };
-  }
-  if (tv.kind === "union") {
-    return simplifyUnion(tv.members.map((m) => deepCloneTypeValue(m, map)));
-  }
-  return tv;
-}
-function mergeObjectProperties(a, b) {
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(a.properties), ...Object.keys(b.properties)]);
-  const merged = {};
-  for (const k of allKeys) {
-    const av = a.properties[k];
-    const bv = b.properties[k];
-    if (av && bv) {
-      merged[k] = simplifyUnion([av, bv]);
-    } else {
-      merged[k] = av ?? bv;
-    }
-  }
-  return { kind: "object", properties: merged, id: a.id };
-}
-function typeValueToString(tv) {
-  return typeValueToStringInner(tv, /* @__PURE__ */ new Set());
-}
-function typeValueToStringInner(tv, seen, depth = 0) {
-  if (depth > 48) return "\u2026";
-  const recur = (inner) => {
-    if (inner && typeof inner === "object") {
-      if (seen.has(inner)) return "\u2026";
-      seen.add(inner);
-      const out = typeValueToStringInner(inner, seen, depth + 1);
-      seen.delete(inner);
-      return out;
-    }
-    return typeValueToStringInner(inner, seen, depth + 1);
-  };
-  switch (tv.kind) {
-    case "literal": {
-      const v2 = tv.value;
-      if (v2 === null) return "null";
-      if (v2 === void 0) return "undefined";
-      if (typeof v2 === "string") return JSON.stringify(v2);
-      return String(v2);
-    }
-    case "primitive":
-      return tv.type;
-    case "refined":
-      return tv.refinement.name;
-    case "object": {
-      const entries = Object.entries(tv.properties);
-      if (entries.length === 0) return "{}";
-      const inner = entries.map(([k, v2]) => `${k}: ${recur(v2)}`).join(", ");
-      return `{ ${inner} }`;
-    }
-    case "array":
-      return `${recur(tv.element)}[]`;
-    case "tuple": {
-      const inner = tv.elements.map(recur).join(", ");
-      return `[${inner}]`;
-    }
-    case "function": {
-      const sig = getFnSig(tv);
-      if (sig) {
-        const params2 = sig.paramTypes.map((p, i) => `${tv.params[i]}: ${recur(p)}`).join(", ");
-        return `(${params2}) => ${recur(sig.returnType)}`;
-      }
-      const params = tv.params.join(", ");
-      return `(${params}) => ...`;
-    }
-    case "promise":
-      return `Promise<${recur(tv.value)}>`;
-    case "instance": {
-      const entries = Object.entries(tv.properties);
-      if (entries.length === 0) return tv.className;
-      const inner = entries.map(([k, v2]) => `${k}: ${recur(v2)}`).join(", ");
-      return `${tv.className} { ${inner} }`;
-    }
-    case "union": {
-      return tv.members.map(recur).join(" | ");
-    }
-    case "never":
-      return "never";
-    case "unknown":
-      return "unknown";
-  }
-}
-function narrowType(tv, predicate) {
-  if (tv.kind === "union") {
-    return simplifyUnion(tv.members.filter(predicate));
-  }
-  return predicate(tv) ? tv : T.never;
-}
-function subtractType(tv, predicate) {
-  return narrowType(tv, (m) => !predicate(m));
-}
-function getPrimitiveTypeOf(tv) {
-  if (tv.kind === "literal") {
-    const v2 = tv.value;
-    if (v2 === null) return "object";
-    return typeof v2;
-  }
-  if (tv.kind === "primitive") return tv.type;
-  if (tv.kind === "refined") return getPrimitiveTypeOf(tv.base);
-  if (tv.kind === "object") return "object";
-  if (tv.kind === "array" || tv.kind === "tuple") return "object";
-  if (tv.kind === "function") return "function";
-  if (tv.kind === "promise") return "object";
-  if (tv.kind === "instance") return "object";
-  return void 0;
-}
-function getRefinedBase(tv) {
-  return tv.kind === "refined" ? getRefinedBase(tv.base) : tv;
-}
-function isFnSig(tv) {
-  return tv.kind === "function" && "_signature" in tv;
-}
-function getFnSig(tv) {
-  if (tv.kind === "function" && "_signature" in tv) {
-    return tv._signature;
-  }
-  return void 0;
-}
-
-// src/refinements/range.ts
-function formatRangeName(meta) {
-  const parts = [];
-  if (meta.integer) parts.push("integer");
-  else parts.push("number");
-  const constraints = [];
-  if (meta.min != null) {
-    constraints.push(meta.minExclusive ? `> ${meta.min}` : `>= ${meta.min}`);
-  }
-  if (meta.max != null) {
-    constraints.push(meta.maxExclusive ? `< ${meta.max}` : `<= ${meta.max}`);
-  }
-  if (constraints.length > 0) parts.push(`(${constraints.join(", ")})`);
-  return parts.join(" ");
-}
-function createRangeRefinement(meta) {
-  return {
-    name: formatRangeName(meta),
-    meta: { ...meta },
-    check(value) {
-      if (typeof value !== "number") return false;
-      if (meta.integer && !Number.isInteger(value)) return false;
-      if (meta.min != null) {
-        if (meta.minExclusive ? value <= meta.min : value < meta.min) return false;
-      }
-      if (meta.max != null) {
-        if (meta.maxExclusive ? value >= meta.max : value > meta.max) return false;
-      }
-      return true;
-    },
-    ops: {
-      ">="(self, other) {
-        const m = getRangeMeta(self);
-        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
-        if (m.min != null) {
-          if (m.minExclusive && m.min >= other.value) return T.literal(true);
-          if (!m.minExclusive && m.min >= other.value) return T.literal(true);
-        }
-        if (m.max != null) {
-          if (m.maxExclusive && m.max <= other.value) return T.literal(false);
-          if (!m.maxExclusive && m.max < other.value) return T.literal(false);
-        }
-        return void 0;
-      },
-      ">"(self, other) {
-        const m = getRangeMeta(self);
-        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
-        if (m.min != null) {
-          if (m.minExclusive && m.min >= other.value) return T.literal(true);
-          if (!m.minExclusive && m.min > other.value) return T.literal(true);
-        }
-        if (m.max != null) {
-          if (m.max <= other.value) return T.literal(false);
-        }
-        return void 0;
-      },
-      "<="(self, other) {
-        const m = getRangeMeta(self);
-        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
-        if (m.max != null) {
-          if (m.maxExclusive && m.max <= other.value) return T.literal(true);
-          if (!m.maxExclusive && m.max <= other.value) return T.literal(true);
-        }
-        if (m.min != null) {
-          if (m.minExclusive && m.min >= other.value) return T.literal(false);
-          if (!m.minExclusive && m.min > other.value) return T.literal(false);
-        }
-        return void 0;
-      },
-      "<"(self, other) {
-        const m = getRangeMeta(self);
-        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
-        if (m.max != null) {
-          if (m.maxExclusive && m.max <= other.value) return T.literal(true);
-          if (!m.maxExclusive && m.max < other.value) return T.literal(true);
-        }
-        if (m.min != null) {
-          if (m.min >= other.value) return T.literal(false);
-        }
-        return void 0;
-      }
-    }
-  };
-}
-function createRange(meta) {
-  if (meta.min != null && meta.max != null && meta.min === meta.max && !meta.minExclusive && !meta.maxExclusive) {
-    return T.literal(meta.min);
-  }
-  return T.refine(T.number, createRangeRefinement(meta));
-}
-function isRange(tv) {
-  if (tv.kind !== "refined") return false;
-  const m = tv.refinement.meta;
-  return m.min !== void 0 || m.max !== void 0 || m.minExclusive !== void 0 || m.maxExclusive !== void 0 || m.integer !== void 0;
-}
-function getRangeMeta(tv) {
-  if (tv.kind !== "refined") return void 0;
-  const m = tv.refinement.meta;
-  if (m.min !== void 0 || m.max !== void 0 || m.minExclusive !== void 0 || m.maxExclusive !== void 0 || m.integer !== void 0) {
-    return m;
-  }
-  return void 0;
-}
-
-// src/refinements/template.ts
-function tvTemplateViews(parts) {
-  return viewTemplateParts(
-    parts,
-    (p) => p.kind === "literal" && typeof p.value === "string" ? { fixed: p.value } : { render: typeValueToString(p) }
-  );
-}
-function formatTemplateName(parts) {
-  return formatTemplateNameViews(tvTemplateViews(parts));
-}
-function normalizeParts(parts) {
-  const merged = mergeAdjacentFixedViews(tvTemplateViews(parts), (text) => ({
-    fixed: text,
-    render: text,
-    part: T.literal(text)
-  }));
-  const out = [];
-  for (const { part: p } of merged) {
-    const last = out[out.length - 1];
-    if (last?.kind === "primitive" && last.type === "string" && p.kind === "primitive" && p.type === "string") {
-    } else {
-      out.push(p);
-    }
-  }
-  return out;
-}
-function createTemplateRefinement(parts) {
-  return {
-    name: formatTemplateName(parts),
-    meta: { parts },
-    check(value) {
-      if (typeof value !== "string") return false;
-      return templateMatchesValue(value, tvTemplateViews(parts));
-    },
-    ops: {
-      "+"(self, other) {
-        return concatTemplates(self, other);
-      }
-    },
-    methods: {
-      startsWith(_self, args) {
-        const arg = args[0];
-        if (arg?.kind !== "literal" || typeof arg.value !== "string") return void 0;
-        const parts2 = _self.refinement.meta.parts;
-        const d = decideStartsWith(knownPrefixOfViews(tvTemplateViews(parts2)), arg.value);
-        return d === "unknown" ? void 0 : T.literal(d);
-      },
-      endsWith(_self, args) {
-        const arg = args[0];
-        if (arg?.kind !== "literal" || typeof arg.value !== "string") return void 0;
-        const parts2 = _self.refinement.meta.parts;
-        const d = decideEndsWith(knownSuffixOfViews(tvTemplateViews(parts2)), arg.value);
-        return d === "unknown" ? void 0 : T.literal(d);
-      },
-      includes(_self, args) {
-        const arg = args[0];
-        if (arg?.kind !== "literal" || typeof arg.value !== "string") return void 0;
-        const parts2 = _self.refinement.meta.parts;
-        const d = decideIncludes(allFixedTextOfViews(tvTemplateViews(parts2)), arg.value);
-        return d === "unknown" ? void 0 : T.literal(d);
-      }
-    },
-    properties: {
-      length(_self) {
-        const parts2 = _self.refinement.meta.parts;
-        const hasAbstract = parts2.some((p) => p.kind !== "literal");
-        if (!hasAbstract) return void 0;
-        return createRange({ min: allFixedTextOfViews(tvTemplateViews(parts2)).length });
-      }
-    }
-  };
-}
-function createTemplate(parts) {
-  const normalized = normalizeParts(parts);
-  if (normalized.length === 1 && normalized[0].kind === "literal") {
-    return normalized[0];
-  }
-  if (normalized.length === 1 && normalized[0].kind === "primitive" && normalized[0].type === "string") {
-    return T.string;
-  }
-  return T.refine(T.string, createTemplateRefinement(normalized));
-}
-function getTemplateParts(tv) {
-  if (tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts)) {
-    return tv.refinement.meta.parts;
-  }
-  return void 0;
-}
-function concatTemplates(left, right) {
-  const leftParts = getTemplateParts(left) ?? [left];
-  const rightParts = getTemplateParts(right) ?? [right];
-  return createTemplate([...leftParts, ...rightParts]);
-}
-
-// src/ops.ts
-function bothLiteral(l, r) {
-  if (l.kind === "literal" && r.kind === "literal") {
-    return { lv: l.value, rv: r.value };
-  }
-  return null;
-}
-function isNullishLiteral(tv) {
-  return tv.kind === "literal" && (tv.value === null || tv.value === void 0);
-}
-function definitelyNotNullish(tv) {
-  switch (tv.kind) {
-    case "literal":
-      return tv.value !== null && tv.value !== void 0;
-    case "primitive":
-    case "object":
-    case "array":
-    case "tuple":
-    case "function":
-    case "instance":
-    case "promise":
-      return true;
-    case "refined":
-      return definitelyNotNullish(tv.base);
-    case "union":
-      return tv.members.every(definitelyNotNullish);
-    default:
-      return false;
-  }
-}
-var Ops = {
-  add(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) {
-      return T.literal(lit3.lv + lit3.rv);
-    }
-    const leftIsString = isSubtypeOf(left, T.string) || isTemplate(left);
-    const rightIsString = isSubtypeOf(right, T.string) || isTemplate(right);
-    if (leftIsString || rightIsString) {
-      const hasStructure = left.kind === "literal" && typeof left.value === "string" || right.kind === "literal" && typeof right.value === "string" || isTemplate(left) || isTemplate(right);
-      if (hasStructure) {
-        return concatTemplates(left, right);
-      }
-      return T.string;
-    }
-    if (isSubtypeOf(left, T.number) && isSubtypeOf(right, T.number)) {
-      return T.number;
-    }
-    return T.union(T.number, T.string);
-  },
-  strictEq(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv === lit3.rv);
-    if (isNullishLiteral(right) && definitelyNotNullish(left) || isNullishLiteral(left) && definitelyNotNullish(right)) {
-      return T.literal(false);
-    }
-    return T.boolean;
-  },
-  strictNeq(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv !== lit3.rv);
-    if (isNullishLiteral(right) && definitelyNotNullish(left) || isNullishLiteral(left) && definitelyNotNullish(right)) {
-      return T.literal(true);
-    }
-    return T.boolean;
-  },
-  gt(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv > lit3.rv);
-    return T.boolean;
-  },
-  lt(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv < lit3.rv);
-    return T.boolean;
-  },
-  gte(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv >= lit3.rv);
-    return T.boolean;
-  },
-  lte(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv <= lit3.rv);
-    return T.boolean;
-  },
-  not(operand) {
-    if (operand.kind === "literal") return T.literal(!operand.value);
-    return T.boolean;
-  }
-};
-var binaryOpMap = {
-  "+": Ops.add,
-  "===": Ops.strictEq,
-  "!==": Ops.strictNeq,
-  ">": Ops.gt,
-  "<": Ops.lt,
-  ">=": Ops.gte,
-  "<=": Ops.lte
-};
-function applyBinaryOp(op, left, right) {
-  const fn2 = binaryOpMap[op];
-  if (!fn2) return T.unknown;
-  return fn2(left, right);
-}
-function dispatchBinaryOp(op, left, right) {
-  if (left.kind === "refined" && left.refinement.ops?.[op]) {
-    const result = left.refinement.ops[op](left, right);
-    if (result !== void 0) return result;
-  }
-  if (right.kind === "refined" && right.refinement.ops?.[op]) {
-    const result = right.refinement.ops[op](right, left);
-    if (result !== void 0) return result;
-  }
-  const baseLeft = left.kind === "refined" ? left.base : left;
-  const baseRight = right.kind === "refined" ? right.base : right;
-  if (baseLeft !== left || baseRight !== right) {
-    return dispatchBinaryOp(op, baseLeft, baseRight);
-  }
-  return applyBinaryOp(op, left, right);
-}
-function dispatchMethod(receiver, name, args) {
-  if (receiver.kind === "refined" && receiver.refinement.methods?.[name]) {
-    const result = receiver.refinement.methods[name](receiver, args);
-    if (result !== void 0) return result;
-  }
-  if (receiver.kind === "refined") {
-    return dispatchMethod(receiver.base, name, args);
-  }
-  return void 0;
-}
-function dispatchProperty(receiver, name) {
-  if (receiver.kind === "refined" && receiver.refinement.properties?.[name]) {
-    const result = receiver.refinement.properties[name](receiver);
-    if (result !== void 0) return result;
-  }
-  if (receiver.kind === "refined") {
-    return dispatchProperty(receiver.base, name);
-  }
-  return void 0;
-}
+} from "./chunk-VVSVQKWF.js";
 
 // src/environment.ts
 function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
@@ -978,7 +347,7 @@ function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
       const val = store.get(name);
       if (val !== void 0) return val;
       if (parent) return parent.lookup(name);
-      return T.undefined;
+      return unknown;
     },
     bind(name, value) {
       store.set(name, value);
@@ -1041,7 +410,8 @@ stub.onSecondCall = function(value) {
   return { kind: "mock-helper", onSecondCallValue: value };
 };
 stub.withArgs = function(...args) {
-  return { kind: "mock-helper", withArgsCases: [{ args, returnValue: T.unknown }] };
+  const unknownAbs = { shape: { k: "unknown" }, conf: "partial" };
+  return { kind: "mock-helper", withArgsCases: [{ args, returnValue: unknownAbs }] };
 };
 stub.callsFake = function(fn2) {
   return { kind: "mock-helper", callsFakeImpl: fn2 };
@@ -1055,57 +425,6 @@ spy.returns = function(value) {
 function mock() {
   return { kind: "mock-helper" };
 }
-function mockArgMatches(declared, actual) {
-  if (actual === void 0) return false;
-  if (typeValueEquals(declared, actual)) return true;
-  if (declared.kind === "primitive" && actual.kind === "literal") {
-    const t = typeof actual.value;
-    return declared.type === "number" && t === "number" || declared.type === "string" && t === "string" || declared.type === "boolean" && t === "boolean" || declared.type === "bigint" && t === "bigint" || declared.type === "symbol" && t === "symbol";
-  }
-  return false;
-}
-function mockHelperToTypeValue(helper, env) {
-  if (helper.callsFakeImpl) {
-    if (helper.callsFakeImpl.kind === "function") {
-      return helper.callsFakeImpl;
-    }
-    const plain = T.fn(["...args"], { type: "BlockStatement", body: [] }, env);
-    plain._directReturn = helper.callsFakeImpl;
-    return plain;
-  }
-  let defaultReturn;
-  if (helper.resolvedValue) {
-    defaultReturn = T.promise(helper.resolvedValue);
-  } else if (helper.rejectedValue) {
-    defaultReturn = T.never;
-  } else if (helper.returnValue) {
-    defaultReturn = helper.returnValue;
-  } else if (helper.onFirstCallValue) {
-    defaultReturn = helper.onFirstCallValue;
-  } else {
-    defaultReturn = T.unknown;
-  }
-  if (helper.withArgsCases?.length) {
-    const cases = helper.withArgsCases;
-    return T.fnSig(
-      cases[0].args.map(() => T.unknown),
-      T.union(...cases.map((c) => c.returnValue), defaultReturn),
-      T.never,
-      (args) => {
-        for (const c of cases) {
-          if (c.args.every((a, i) => mockArgMatches(a, args[i]))) {
-            return c.returnValue;
-          }
-        }
-        return defaultReturn;
-      }
-    );
-  }
-  const body = { type: "BlockStatement", body: [] };
-  const fn2 = T.fn(["...args"], body, env);
-  fn2._directReturn = defaultReturn;
-  return fn2;
-}
 
 // src/algebra/phi.ts
 var phiStack = [pTrue];
@@ -1147,6 +466,9 @@ function formatAbs(a, opts = {}) {
     parts.push(`where ${predToString(a.pred)}`);
   }
   parts.push(`#${a.conf}`);
+  if (a.pathNote) {
+    parts.push(a.pathNote);
+  }
   return parts.join("  ");
 }
 function formatShapeSlot(a) {
@@ -1163,8 +485,10 @@ function formatShape(a) {
       return "never";
     case "any":
       return "any";
-    case "unknown":
+    case "unknown": {
+      if (a.term?.op === "lit" && a.term.value === void 0) return "undefined";
       return "unknown";
+    }
     case "prim": {
       const lv = litValue(a);
       if (typeof lv === "number" && !Number.isFinite(lv)) return String(lv);
@@ -1311,6 +635,9 @@ function string() {
 function boolean() {
   return makeBuilder("boolean", []);
 }
+function any() {
+  return makeBuilder(void 0, []);
+}
 function array(item) {
   if (!isConstraint(item))
     throw new Error("nudo: array(item) \u671F\u671B\u7EA6\u675F\u503C\uFF08number()/string()/\u2026\u6216\u5176\u7EC4\u5408\u5B50\uFF09");
@@ -1541,6 +868,46 @@ function constraintToEntryAbs(c, paramName) {
   }
   return constraintOnTermAbs(c, t);
 }
+function memberLitValue(m) {
+  const leaves = [];
+  const visit = (p2) => {
+    if (p2.op === "and") {
+      p2.args.forEach(visit);
+      return;
+    }
+    leaves.push(p2);
+  };
+  m.preds.forEach(visit);
+  if (leaves.length !== 1) return void 0;
+  const p = leaves[0];
+  if (p.op !== "eq") return void 0;
+  if (p.a.op === "var" && p.b.op === "lit") return p.b.value;
+  if (p.b.op === "var" && p.a.op === "lit") return p.a.value;
+  return void 0;
+}
+function samePrimLiteralUnionAbs(members, t) {
+  if (members.length === 0) return void 0;
+  const values = [];
+  let prim;
+  for (const m of members) {
+    const v2 = memberLitValue(m);
+    if (v2 === void 0) return void 0;
+    if (v2 === null) return void 0;
+    const mp = m.prim ?? (typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : "boolean");
+    if (prim === void 0) prim = mp;
+    else if (prim !== mp) return void 0;
+    values.push(v2);
+  }
+  if (prim === void 0) return void 0;
+  const uniq = [];
+  for (const v2 of values) {
+    if (!uniq.some((u) => Object.is(u, v2))) uniq.push(v2);
+  }
+  const disj = or(
+    ...uniq.map((v2) => eq(t, lit(v2)))
+  );
+  return abs({ k: "prim", type: prim }, t, disj, "path");
+}
 function constraintOnTermAbs(c, t) {
   if (c.fields) {
     const slots = {};
@@ -1553,6 +920,8 @@ function constraintOnTermAbs(c, t) {
     return abs({ k: "obj", slots }, t, void 0, "path");
   }
   if (c.members) {
+    const litUnion = samePrimLiteralUnionAbs(c.members, t);
+    if (litUnion) return litUnion;
     const joined = c.members.map((m) => constraintOnTermAbs(m, t)).reduce((a, b) => joinAbs(a, b));
     if (joined.shape.k === "prim" && joined.pred === void 0 && c.members.every((m) => m.prim === joined.shape.type)) {
       const type = joined.shape.type;
@@ -1735,12 +1104,13 @@ function rewriteSidecarSource(src, fromFile) {
   const keepTs = fromFile?.endsWith(".nudo.ts") === true;
   const ast = parseSource(src, keepTs ? { keepTs: true } : void 0);
   const cuts = [];
-  const exportNames = [];
+  const exportPairs = [];
   const imports = [];
+  const DEFAULT_LOCAL = "__nudoDefault";
   const badExport = (what) => {
     collectDiag({
       code: "nudo:interface-load",
-      message: `sidecar ${what}; only 'export const <name> = \u2026' is a recognized export form`,
+      message: `sidecar ${what}; recognized export forms are 'export const <name> = \u2026' and 'export default <constraint|fn>'`,
       file: fromFile
     });
   };
@@ -1764,7 +1134,7 @@ function rewriteSidecarSource(src, fromFile) {
         if (decl.kind === "const") {
           let simple = true;
           for (const d of decl.declarations) {
-            if (d.id.type === "Identifier") exportNames.push(d.id.name);
+            if (d.id.type === "Identifier") exportPairs.push({ key: d.id.name, expr: d.id.name });
             else simple = false;
           }
           if (!simple) badExport("'export const' with destructuring pattern");
@@ -1788,15 +1158,40 @@ function rewriteSidecarSource(src, fromFile) {
     }
     if (stmt.type === "ExportDefaultDeclaration") {
       const decl = stmt.declaration;
-      if ((decl?.type === "FunctionDeclaration" || decl?.type === "ClassDeclaration") && stmt.start != null && decl.start != null) {
-        const kind = decl.type === "FunctionDeclaration" ? "function" : "class";
-        badExport(`'export default ${kind}'`);
-        cuts.push({ start: stmt.start, end: decl.start, text: "" });
-      } else {
-        badExport("'export default'");
-        if (stmt.start != null && stmt.end != null) {
-          cuts.push({ start: stmt.start, end: stmt.end, text: "" });
+      if (decl && (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") && stmt.start != null && decl.start != null) {
+        if (decl.id?.name) {
+          exportPairs.push({ key: decl.id.name, expr: decl.id.name });
+          exportPairs.push({ key: "default", expr: decl.id.name });
+        } else {
+          exportPairs.push({ key: "default", expr: DEFAULT_LOCAL });
+          if (decl.start != null && decl.end != null) {
+            const kind = decl.type === "FunctionDeclaration" ? "function" : "class";
+            cuts.push({
+              start: stmt.start,
+              end: decl.start,
+              text: `var ${DEFAULT_LOCAL} = `
+            });
+            void kind;
+          }
+        }
+        if (decl.id?.name) {
+          cuts.push({ start: stmt.start, end: decl.start, text: "" });
         }
+        continue;
+      }
+      if (decl && stmt.start != null && decl.start != null && decl.end != null) {
+        exportPairs.push({ key: "default", expr: DEFAULT_LOCAL });
+        cuts.push({
+          start: stmt.start,
+          end: decl.start,
+          text: `var ${DEFAULT_LOCAL} = `
+        });
+        cuts.push({ start: decl.end, end: stmt.end ?? decl.end, text: ";" });
+        continue;
+      }
+      badExport("'export default'");
+      if (stmt.start != null && stmt.end != null) {
+        cuts.push({ start: stmt.start, end: stmt.end, text: "" });
       }
       continue;
     }
@@ -1816,20 +1211,21 @@ function rewriteSidecarSource(src, fromFile) {
   const merged = [];
   for (const c of cuts) {
     const last = merged[merged.length - 1];
-    if (last && c.start <= last.end) {
+    if (last && c.start <= last.end && last.text === "" && c.text === "") {
       last.end = Math.max(last.end, c.end);
     } else {
-      merged.push({ start: c.start, end: c.end });
+      merged.push({ start: c.start, end: c.end, text: c.text });
     }
   }
   let code = "";
   let pos = 0;
   for (const c of merged) {
-    code += src.slice(pos, c.start);
+    if (c.start < pos) continue;
+    code += src.slice(pos, c.start) + c.text;
     pos = c.end;
   }
   code += src.slice(pos);
-  return { code, exportNames, imports };
+  return { code, exportPairs, imports };
 }
 var TS_STMT_CUT_TYPES = /* @__PURE__ */ new Set([
   "TSInterfaceDeclaration",
@@ -1903,7 +1299,7 @@ function collectTsSyntaxCuts(node, src, cuts = []) {
 }
 function execSidecar(src, opts, chain, preloaded) {
   const fromFile = opts?.fromFile;
-  const { code, exportNames, imports } = rewriteSidecarSource(src, fromFile);
+  const { code, exportPairs, imports } = rewriteSidecarSource(src, fromFile);
   const prologue = [];
   const deps = {};
   for (const imp of imports) {
@@ -2015,9 +1411,12 @@ function execSidecar(src, opts, chain, preloaded) {
   for (const local of Object.keys(deps)) {
     prologue.push(`var ${local} = __nudoDeps[${JSON.stringify(local)}];`);
   }
+  const returnObj = exportPairs.map(
+    (p) => p.key === p.expr ? p.key : `${JSON.stringify(p.key)}: ${p.expr}`
+  ).join(", ");
   const body = `${prologue.length > 0 ? `${prologue.join("\n")}
 ` : ""}${code}
-return { ${exportNames.join(", ")} };`;
+return { ${returnObj} };`;
   const fn2 = new Function(
     ...Object.keys(sidecarInjects),
     "__nudoInjects",
@@ -2269,28 +1668,134 @@ function localNamedExports(source) {
       }
     }
   }
+  const identName = (n) => {
+    if (!n) return void 0;
+    if (n.type === "Identifier" && typeof n.name === "string") return n.name;
+    if (n.type === "Literal" && typeof n.value === "string") return n.value;
+    return void 0;
+  };
+  const localClasses = /* @__PURE__ */ new Map();
   for (const stmt of ast.program.body) {
-    if (stmt.type !== "ExportNamedDeclaration") continue;
-    if (stmt.source) continue;
-    const d = stmt.declaration;
-    if (!d) {
-      for (const spec of stmt.specifiers) {
-        if (spec.type !== "ExportSpecifier") continue;
-        const exported = spec.exported;
-        const name = exported.type === "Identifier" ? exported.name : exported.value;
-        if (!name || name === "default") continue;
-        const local = spec.local;
-        const localName = local.type === "Identifier" ? local.name : local.value;
-        if (localName && importedLocalNames.has(localName)) continue;
-        out.add(name);
+    const s = stmt;
+    if (s.type !== "ClassDeclaration") continue;
+    const idName = identName(s.id);
+    if (idName) localClasses.set(idName, s);
+  }
+  const addClassMethodKeys = (out2, decl) => {
+    if (!decl || decl.type !== "ClassDeclaration") return;
+    const idName = identName(decl.id);
+    if (!idName) return;
+    const body = decl.body?.body ?? [];
+    for (const m of body) {
+      const mem = m;
+      const isMethod = mem.type === "MethodDefinition" || mem.type === "ClassMethod" || mem.type === "TSDeclareMethod";
+      if (!isMethod) continue;
+      if (mem.kind && mem.kind !== "method") continue;
+      if (mem.static) continue;
+      const keyName = identName(mem.key);
+      if (keyName) out2.add(`${idName}.${keyName}`);
+    }
+  };
+  const isExportsTarget = (n) => {
+    if (!n) return false;
+    if (n.type === "Identifier") return n.name === "exports";
+    if (n.type === "MemberExpression") {
+      return identName(n.object) === "module" && n.property !== void 0 ? identName(n.property) === "exports" : false;
+    }
+    return false;
+  };
+  const cjsPropName = (left) => {
+    if (!left || left.type !== "MemberExpression") return void 0;
+    if (left.computed === true) return void 0;
+    const obj2 = left.object;
+    if (!isExportsTarget(obj2)) return void 0;
+    return identName(left.property);
+  };
+  for (const stmt of ast.program.body) {
+    const s = stmt;
+    if (s.type === "ExportNamedDeclaration") {
+      if (s.source) continue;
+      const d = s.declaration;
+      if (!d) {
+        const specs = s.specifiers ?? [];
+        for (const spec of specs) {
+          if (spec.type !== "ExportSpecifier") continue;
+          const name = identName(spec.exported);
+          if (!name) continue;
+          const localName = identName(spec.local);
+          if (name === "default") {
+            out.add("default");
+            if (localName && !importedLocalNames.has(localName)) out.add(localName);
+            if (localName && !importedLocalNames.has(localName)) {
+              addClassMethodKeys(out, localClasses.get(localName));
+            }
+            continue;
+          }
+          if (localName && importedLocalNames.has(localName)) continue;
+          out.add(name);
+          if (localName) addClassMethodKeys(out, localClasses.get(localName));
+        }
+        continue;
+      }
+      if (d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") {
+        const idName = identName(d.id);
+        if (idName) out.add(idName);
+        if (d.type === "ClassDeclaration" && idName) {
+          addClassMethodKeys(out, d);
+        }
+      } else if (d.type === "VariableDeclaration") {
+        const decls = d.declarations ?? [];
+        for (const decl of decls) {
+          const idName = identName(decl.id);
+          if (idName) out.add(idName);
+        }
       }
       continue;
     }
-    if (d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") {
-      if (d.id) out.add(d.id.name);
-    } else if (d.type === "VariableDeclaration") {
-      for (const decl of d.declarations) {
-        if (decl.id.type === "Identifier") out.add(decl.id.name);
+    if (s.type === "ExportDefaultDeclaration") {
+      out.add("default");
+      const d = s.declaration;
+      if (d) {
+        if ((d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") && d.id) {
+          const idName = identName(d.id);
+          if (idName) out.add(idName);
+          if (d.type === "ClassDeclaration" && idName) {
+            addClassMethodKeys(out, d);
+          }
+        } else if (d.type === "Identifier") {
+          const n = identName(d);
+          if (n && !importedLocalNames.has(n)) {
+            out.add(n);
+            addClassMethodKeys(out, localClasses.get(n));
+          }
+        }
+      }
+      continue;
+    }
+    if (s.type === "ExpressionStatement") {
+      const expr = s.expression;
+      if (!expr || expr.type !== "AssignmentExpression" || expr.operator !== "=") continue;
+      const left = expr.left;
+      const right = expr.right;
+      if (!left || !right) continue;
+      const prop = cjsPropName(left);
+      if (prop && prop !== "default") out.add(prop);
+      if (isExportsTarget(left)) {
+        if (right.type === "ObjectExpression") {
+          const props = right.properties ?? [];
+          for (const p of props) {
+            if (p.type !== "ObjectProperty" && p.type !== "Property") continue;
+            const keyName = identName(p.key);
+            if (keyName && keyName !== "default") out.add(keyName);
+            else {
+              const valName = identName(p.value);
+              if (valName) out.add(valName);
+            }
+          }
+        } else if (right.type === "Identifier") {
+          const n = identName(right);
+          if (n && !importedLocalNames.has(n)) out.add(n);
+        }
       }
     }
   }
@@ -2304,7 +1809,9 @@ function generatedExportNames(sidecarSrc) {
   } catch {
     return out;
   }
-  for (const stmt of ast.program.body) {
+  const stmts = ast.program.body;
+  for (let i = 0; i < stmts.length; i++) {
+    const stmt = stmts[i];
     if (stmt.type !== "ExportNamedDeclaration") continue;
     if (stmt.source) continue;
     const d = stmt.declaration;
@@ -2318,25 +1825,26 @@ function generatedExportNames(sidecarSrc) {
       if (d.id) names.push(d.id.name);
     }
     if (names.length === 0) continue;
-    if (leadingCommentHas(stmt.start, sidecarSrc)) {
+    if (regionHasGeneratedMarker(stmts, i, sidecarSrc)) {
       for (const n of names) out.add(n);
     }
   }
   return out;
 }
-function leadingCommentHas(pos, src) {
-  const lines = src.slice(0, pos).replace(/\n$/, "").split("\n");
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i].trim();
-    if (line === "") break;
-    if (line === "*/") continue;
-    if (line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) {
-      if (/@generated/.test(line)) return true;
-      continue;
-    }
+function regionHasGeneratedMarker(stmts, exportIdx, src) {
+  const exportStart = stmts[exportIdx].start;
+  if (exportStart == null) return false;
+  let regionStart = 0;
+  for (let j = exportIdx - 1; j >= 0; j--) {
+    const prev = stmts[j];
+    if (prev.type === "ImportDeclaration" || prev.type === "VariableDeclaration") continue;
+    regionStart = prev.end ?? 0;
     break;
   }
-  return false;
+  return src.slice(regionStart, exportStart).split("\n").some((line) => {
+    const t = line.trim();
+    return (t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) && /@generated/.test(t);
+  });
 }
 function sidecarAutoBindAllowed(sidecarPath, autoBind) {
   if (isNodeModulesPath(sidecarPath)) return false;
@@ -2344,6 +1852,18 @@ function sidecarAutoBindAllowed(sidecarPath, autoBind) {
   if (typeof autoBind === "function") return autoBind(sidecarPath) === true;
   return false;
 }
+function isDefaultExportLocal(source, localName) {
+  const reList = new RegExp(
+    `export\\s*\\{[^}]*\\b${localName}\\s+as\\s+default\\b[^}]*\\}`,
+    "m"
+  );
+  const reDefaultFn = new RegExp(
+    `export\\s+default\\s+(?:async\\s+)?function\\s+${localName}\\b`,
+    "m"
+  );
+  const reDefaultId = new RegExp(`export\\s+default\\s+${localName}\\b`, "m");
+  return reList.test(source) || reDefaultFn.test(source) || reDefaultId.test(source);
+}
 function loadSidecarBinding(source, fnName, opts) {
   const { loadModule, fromFile, autoBind } = opts;
   if (!loadModule || !fromFile) return { ok: false };
@@ -2353,6 +1873,7 @@ function loadSidecarBinding(source, fnName, opts) {
   const spec = `./${sidecarPath.slice(sidecarPath.lastIndexOf("/") + 1)}`;
   const sidecarSrc = loadModule(spec, fromFile);
   if (sidecarSrc === void 0) return { ok: false };
+  if (sidecarSrc === source) return { ok: false };
   let exports;
   try {
     exports = execNudoModule(sidecarSrc, { loadModule, fromFile: sidecarPath });
@@ -2364,7 +1885,20 @@ function loadSidecarBinding(source, fnName, opts) {
     });
     return { ok: false };
   }
-  const binding = exports[fnName];
+  let binding = exports[fnName];
+  if (binding === void 0 && exports.default !== void 0 && isDefaultExportLocal(source, fnName)) {
+    binding = exports.default;
+  }
+  if (binding === void 0 && fnName.includes(".")) {
+    const [cls, method] = fnName.split(".", 2);
+    binding = exports[`${cls}_${method}`];
+    if (binding === void 0) {
+      const bag = exports[cls];
+      if (bag && typeof bag === "object" && !isNudoConstraint(bag)) {
+        binding = bag[method];
+      }
+    }
+  }
   if (binding === void 0) return { ok: false };
   if (!isNudoConstraint(binding)) {
     collectDiag2({
@@ -2382,11 +1916,16 @@ function loadSidecarBinding(source, fnName, opts) {
     });
     return { ok: false };
   }
+  const generatedNames = generatedExportNames(sidecarSrc);
+  const isGenerated = generatedNames.has(fnName) || (fnName.includes(".") ? (() => {
+    const [cls, method] = fnName.split(".", 2);
+    return generatedNames.has(`${cls}_${method}`) || generatedNames.has(cls);
+  })() : false);
   return {
     ok: true,
     sidecarPath,
     constraint: binding,
-    generated: generatedExportNames(sidecarSrc).has(fnName)
+    generated: isGenerated
   };
 }
 function boundsOf(c) {
@@ -2683,6 +2222,27 @@ function fmtConstraint(c) {
 function formatConstraint(c) {
   return fmtConstraint(c);
 }
+function formatEffectiveInterfaceDisplay(eff) {
+  const params = eff.params.map((p) => `${p.param}: ${formatConstraint(p.constraint)}`).join(", ");
+  let s = `(${params})`;
+  if (eff.returns) s += ` \u2192 ${formatConstraint(eff.returns.constraint)}`;
+  return s;
+}
+function formatInterfaceTierLine(source) {
+  return `\u25CF interface / ${source}`;
+}
+function interfaceTierOf(source, fnName, fromFile, opts = {}) {
+  if (!localNamedExports(source).has(fnName)) return void 0;
+  const eff = effectiveInterface(source, fnName, { fromFile, ...opts });
+  const src = eff?.source ?? "implicit";
+  if (eff && src !== "implicit") {
+    return { source: src, display: formatEffectiveInterfaceDisplay(eff) };
+  }
+  return { source: src };
+}
+function interfaceSourceOf(source, fnName, fromFile, opts = {}) {
+  return interfaceTierOf(source, fnName, fromFile, opts)?.source;
+}
 
 // src/algebra/fn-fp.ts
 var fnFpCache = /* @__PURE__ */ new Map();
@@ -2866,7 +2426,151 @@ function canSkipLiteralCallScan(source, file) {
   for (const fp of fps.values()) {
     if (fp.nRefs > 0) return false;
   }
-  return true;
+  return true;
+}
+
+// src/algebra/param-surface.ts
+function collectPatternNames(p, top, nested, depth, propKey) {
+  if (!p) return;
+  if (p.type === "Identifier" && p.name) {
+    if (depth === 0) top.push(p.name);
+    else nested.push(p.name);
+    return;
+  }
+  if (p.type === "AssignmentPattern") {
+    collectPatternNames(p.left, top, nested, depth, propKey);
+    return;
+  }
+  if (p.type === "RestElement") {
+    collectPatternNames(p.argument, top, nested, depth, propKey);
+    return;
+  }
+  if (p.type === "ObjectPattern") {
+    for (const prop of p.properties ?? []) {
+      if (prop.type === "RestElement" || prop.argument) {
+        collectPatternNames(prop.argument, top, nested, depth, propKey);
+        continue;
+      }
+      const keyName = prop.key?.type === "Identifier" && prop.key.name ? prop.key.name : prop.key && "value" in prop.key ? String(prop.key.value ?? "") : void 0;
+      const v2 = prop.value ?? prop.key;
+      if (!v2) continue;
+      if (keyName && v2.type === "Identifier" && v2.name && keyName !== v2.name) {
+        if (depth === 0) top.push(keyName);
+        else nested.push(keyName);
+        if (propKey && depth === 0) propKey[keyName] = keyName;
+      }
+      if (v2.type === "Identifier" && v2.name) {
+        if (depth === 0) {
+          top.push(v2.name);
+          if (propKey && keyName) propKey[v2.name] = keyName;
+        } else nested.push(v2.name);
+      } else {
+        collectPatternNames(v2, top, nested, depth + 1, propKey);
+      }
+    }
+    return;
+  }
+  if (p.type === "ArrayPattern") {
+    for (const el of p.elements ?? []) {
+      if (!el) continue;
+      if (el.type === "Identifier" && el.name) {
+        if (depth === 0) top.push(el.name);
+        else nested.push(el.name);
+      } else {
+        collectPatternNames(el, top, nested, depth + 1, propKey);
+      }
+    }
+  }
+}
+function formalParamsFromNodes(params) {
+  const list = params ?? [];
+  return list.map((p, index) => {
+    if (p?.type === "Identifier" && p.name) {
+      return { kind: "id", name: p.name, index };
+    }
+    if (p?.type === "AssignmentPattern") {
+      const left = p.left;
+      if (left?.type === "Identifier" && left.name) {
+        return { kind: "default", name: left.name, index };
+      }
+      const top2 = [];
+      const nested2 = [];
+      const propKey2 = {};
+      if (left) collectPatternNames(left, top2, nested2, 0, propKey2);
+      return {
+        kind: "pattern",
+        placeholder: `_p${index}`,
+        bound: top2,
+        propKey: propKey2,
+        nested: nested2,
+        index
+      };
+    }
+    if (p?.type === "RestElement") {
+      const arg = p.argument;
+      const name = arg?.type === "Identifier" && arg.name ? arg.name : `arg${index}`;
+      return { kind: "rest", name, display: `...${name}`, index };
+    }
+    const top = [];
+    const nested = [];
+    const propKey = {};
+    if (p) collectPatternNames(p, top, nested, 0, propKey);
+    return {
+      kind: "pattern",
+      placeholder: `_p${index}`,
+      bound: top,
+      propKey,
+      nested,
+      index
+    };
+  });
+}
+function formalParamDisplayNames(formals) {
+  return formals.map((f) => {
+    switch (f.kind) {
+      case "id":
+      case "default":
+        return f.name;
+      case "rest":
+        return f.display;
+      case "pattern":
+        return f.placeholder;
+    }
+  });
+}
+function contractParamNameSet(formals) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of formals) {
+    if (f.kind === "id" || f.kind === "default") out.add(f.name);
+    else if (f.kind === "rest") {
+      out.add(f.name);
+      out.add(f.display);
+    } else if (f.kind === "pattern") {
+      out.add(f.placeholder);
+      out.add("_");
+      for (const b of f.bound) out.add(b);
+    }
+  }
+  return out;
+}
+function locateContractParam(formals, contractName) {
+  for (const f of formals) {
+    if (f.kind === "id" || f.kind === "default") {
+      if (f.name === contractName) return { index: f.index };
+    } else if (f.kind === "rest") {
+      if (f.name === contractName || f.display === contractName) {
+        return { index: f.index, rest: true };
+      }
+    } else if (f.kind === "pattern") {
+      if (f.placeholder === contractName || contractName === "_") {
+        return { index: f.index };
+      }
+      if (f.bound.includes(contractName)) {
+        return { index: f.index, field: f.propKey?.[contractName] ?? contractName };
+      }
+    }
+  }
+  return void 0;
 }
 
 // src/algebra/load-deps-fp.ts
@@ -2874,6 +2578,18 @@ var MAX_LOAD_DEP_NODES = 64;
 function extractAllLoadSpecs(source) {
   const specs = /* @__PURE__ */ new Set();
   for (const imp of extractNudoImports(source)) specs.add(imp.spec);
+  const isPathLikeSpec = (spec) => spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/") || /\.(ts|js|mjs|cjs|tsx|jsx)$/.test(spec);
+  const envRe = /@nudo:env\s+([^\n*]+)/g;
+  let envM;
+  while (envM = envRe.exec(source)) {
+    for (const part of envM[1].split(",")) {
+      const spec = part.trim().replace(/^['"]|['"]$/g, "");
+      if (spec && isPathLikeSpec(spec)) specs.add(spec);
+    }
+  }
+  const mockFromRe = /@nudo:mock-module\s+"[^"]+"\s+(?:\{[^}]*\}\s+)?from\s+["']([^"']+)["']/g;
+  let mockM;
+  while (mockM = mockFromRe.exec(source)) specs.add(mockM[1]);
   const patterns = [
     /\bfrom\s*['"]([^'"]+)['"]/g,
     /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
@@ -2893,6 +2609,7 @@ function sidecarSpecsOf(source) {
 function loadModuleDepsFingerprint(source, loadModule, fromFile) {
   const parts = [];
   const paths = [];
+  const contents = [];
   const seen = /* @__PURE__ */ new Set();
   const queue = extractAllLoadSpecs(source).map(
     (spec) => ({ spec, from: fromFile })
@@ -2901,7 +2618,7 @@ function loadModuleDepsFingerprint(source, loadModule, fromFile) {
   let truncated = false;
   const finish = () => {
     parts.sort();
-    return truncated ? { fp: `trunc:${parts.join(",")}`, paths, truncated: true } : { fp: parts.join(","), paths, truncated: false };
+    return truncated ? { fp: `trunc:${parts.join(",")}`, paths, contents, truncated: true } : { fp: parts.join(","), paths, contents, truncated: false };
   };
   const absorbSidecarClosure = (entryFile) => {
     const sidecarPath = sidecarPathOf(entryFile);
@@ -2917,6 +2634,7 @@ function loadModuleDepsFingerprint(source, loadModule, fromFile) {
     n++;
     parts.push(`sidecar:${sidecarPath}=${hashSource(sidecarSrc)}`);
     paths.push(sidecarPath);
+    contents.push({ path: sidecarPath, content: sidecarSrc });
     const sidecarQueue = sidecarSpecsOf(
       sidecarSrc
     ).map((spec) => ({ spec, from: sidecarPath }));
@@ -2933,6 +2651,7 @@ function loadModuleDepsFingerprint(source, loadModule, fromFile) {
       const src = loadModule(cur.spec, cur.from);
       parts.push(`sidecar:${path}=${src === void 0 ? "miss" : hashSource(src)}`);
       paths.push(path);
+      contents.push({ path, content: src ?? null });
       if (src === void 0) continue;
       for (const next of sidecarSpecsOf(src)) {
         const nextPath = resolveDepPath(path, next);
@@ -2953,6 +2672,7 @@ function loadModuleDepsFingerprint(source, loadModule, fromFile) {
     const src = loadModule(cur.spec, cur.from);
     parts.push(`${path}=${src === void 0 ? "miss" : hashSource(src)}`);
     paths.push(path);
+    contents.push({ path, content: src ?? null });
     if (src === void 0) continue;
     for (const next of extractAllLoadSpecs(src)) {
       const nextPath = resolveDepPath(path, next);
@@ -3017,14 +2737,14 @@ function loadModuleId(fn2) {
 }
 function refineDepsFingerprint(source, refine) {
   if (!refine?.loadModule || !refine.fromFile) {
-    return { fp: "-", paths: [], truncated: false };
+    return { fp: "-", paths: [], contents: [], truncated: false };
   }
   return loadModuleDepsFingerprint(source, refine.loadModule, refine.fromFile);
 }
 function generalizeMemoKey(fnName, source, opts) {
   const r = opts.refine;
   const budget = opts.budget ?? defaultLeakBudget;
-  const deps = opts.depsFp ?? (r ? refineDepsFingerprint(source, r) : { fp: "-", paths: [], truncated: false });
+  const deps = opts.depsFp ?? (r ? refineDepsFingerprint(source, r) : { fp: "-", paths: [], contents: [], truncated: false });
   const sc = opts.sidecarFp ?? (r?.loadModule && r.fromFile ? sidecarClosureFingerprint(r.fromFile, r) : void 0);
   const scPath = sc !== void 0 && !sc.startsWith("trunc:") && r?.fromFile ? normPath(sidecarPathOf(r.fromFile)) : void 0;
   const srcPart = generalizeSourceKeyPart(source, fnName, opts.file);
@@ -3074,14 +2794,14 @@ function generalizeMemoSet(key, value, depPaths) {
 function isCacheableAbs(a) {
   return a.conf === "exact" || a.conf === "path" || a.conf === "widened" || a.conf === "mock";
 }
-function termKey(t, rename) {
+function termKey2(t, rename) {
   switch (t.op) {
     case "lit":
       return `L:${typeof t.value}:${String(t.value)}`;
     case "var":
       return `V:${rename?.get(t.id) ?? t.id}`;
     case "app":
-      return `A:${t.fn}(${t.args.map((a) => termKey(a, rename)).join(",")})`;
+      return `A:${t.fn}(${t.args.map((a) => termKey2(a, rename)).join(",")})`;
   }
 }
 function predKey(p, rename) {
@@ -3096,7 +2816,7 @@ function predKey(p, rename) {
     case "le":
     case "gt":
     case "ge":
-      return `${p.op}(${termKey(p.a, rename)},${termKey(p.b, rename)})`;
+      return `${p.op}(${termKey2(p.a, rename)},${termKey2(p.b, rename)})`;
     case "and":
     case "or": {
       const keys = p.args.map((a) => predKey(a, rename)).sort();
@@ -3105,7 +2825,7 @@ function predKey(p, rename) {
     case "not":
       return `not(${predKey(p.arg, rename)})`;
     case "typeof":
-      return `typeof(${termKey(p.t, rename)},${p.type})`;
+      return `typeof(${termKey2(p.t, rename)},${p.type})`;
   }
 }
 function shapeKey(s, seen, rename) {
@@ -3150,7 +2870,7 @@ function shapeKey(s, seen, rename) {
 function absKeyInner(a, seen, rename) {
   if (seen.has(a)) return "cycle";
   seen.add(a);
-  const t = a.term ? `=${termKey(a.term, rename)}` : "";
+  const t = a.term ? `=${termKey2(a.term, rename)}` : "";
   const p = a.pred ? `@${predKey(a.pred, rename)}` : "";
   return `${shapeKey(a.shape, seen, rename)}${t}${p}`;
 }
@@ -3222,6 +2942,11 @@ function collectAbsVars(a, acc, seen) {
       return;
   }
 }
+function collectAbsFreeVars(a) {
+  const acc = /* @__PURE__ */ new Set();
+  collectAbsVars(a, acc, /* @__PURE__ */ new Set());
+  return acc;
+}
 function renameTerm(t, map) {
   if (t.op === "var") {
     const to = map.get(t.id);
@@ -3338,6 +3063,7 @@ function alphaRenameResult(result, fromOrder, toOrder) {
 function extractFn(source, fnName, fileAst) {
   const file = fileAst ?? parseSource(source);
   const env = emptyEnv();
+  const formalsByName = /* @__PURE__ */ new Map();
   for (const stmt of file.program.body) {
     let decl = stmt;
     if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
@@ -3347,30 +3073,53 @@ function extractFn(source, fnName, fileAst) {
       decl = stmt.declaration;
     }
     if (decl.type === "FunctionDeclaration" && decl.id) {
+      const formals = formalParamsFromNodes(decl.params);
       env.fns.set(decl.id.name, {
-        params: decl.params.map((p) => p.type === "Identifier" ? p.name : "_"),
+        params: formalParamDisplayNames(formals),
         body: decl.body,
         async: decl.async === true
       });
+      formalsByName.set(decl.id.name, formals);
+    }
+    if (decl.type === "ClassDeclaration" && decl.id?.name) {
+      const cname = decl.id.name;
+      const body = decl.body?.body ?? [];
+      for (const m of body) {
+        const mem = m;
+        const isMethod = mem.type === "MethodDefinition" || mem.type === "ClassMethod" || mem.type === "TSDeclareMethod";
+        if (!isMethod || !mem.body) continue;
+        if (mem.kind && mem.kind !== "method") continue;
+        if (mem.static) continue;
+        const keyName = mem.key?.type === "Identifier" ? mem.key.name : void 0;
+        if (!keyName) continue;
+        const fullName = `${cname}.${keyName}`;
+        const formals = formalParamsFromNodes(mem.params ?? []);
+        env.fns.set(fullName, {
+          params: formalParamDisplayNames(formals),
+          body: mem.body,
+          async: mem.async === true
+        });
+        formalsByName.set(fullName, formals);
+      }
     }
     if (decl.type === "VariableDeclaration") {
       for (const d of decl.declarations) {
         if (d.id.type === "Identifier" && d.init && (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")) {
           const init = d.init;
+          const formals = formalParamsFromNodes(init.params);
           env.fns.set(d.id.name, {
-            params: init.params.map(
-              (p) => p.type === "Identifier" ? p.name ?? "_" : "_"
-            ),
+            params: formalParamDisplayNames(formals),
             body: init.body,
             async: init.async === true
           });
+          formalsByName.set(d.id.name, formals);
         }
       }
     }
   }
   const fn2 = env.fns.get(fnName);
   if (!fn2) return void 0;
-  return { params: fn2.params, body: fn2.body, env };
+  return { params: fn2.params, body: fn2.body, env, formals: formalsByName.get(fnName) ?? [] };
 }
 function generalizeFromAst(fnName, source, opts = {}) {
   const { key, depPaths, truncated } = generalizeMemoKey(fnName, source, opts);
@@ -3389,7 +3138,7 @@ function generalizeFromAst(fnName, source, opts = {}) {
 function generalizeFromAstUncached(fnName, source, opts = {}) {
   const extracted = extractFn(source, fnName, opts.file);
   if (!extracted) return void 0;
-  const { params, body, env } = extracted;
+  const { params, body, env, formals } = extracted;
   const budget = opts.budget ?? defaultLeakBudget;
   const label = opts.label ?? "A";
   const typeParams = params.map((p, i) => ({
@@ -3505,6 +3254,7 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
       entryShapes,
       fnRels
     ),
+    ...formals.length > 0 ? { formals } : {},
     ...entryReqs ? { entryReqs } : {},
     ...fnRels ? { fnRels } : {},
     ...entryShapes ? { entryShapes } : {},
@@ -3530,9 +3280,8 @@ function formatPoly(name, params, typeParams, symbolic, entryReqs, entryShapes,
     return `${p}: ${id}`;
   }).join(", ");
   const ret = formatShapeSlot(symbolic);
-  const termPart = symbolic.term && symbolic.term.op !== "lit" ? ` = ${termToString(symbolic.term)}` : "";
   const predPart = symbolic.pred && symbolic.pred.op !== "true" ? `  where ${predToString(symbolic.pred)}` : "";
-  return `${name}: (${ps}) => ${ret}${termPart}${predPart}`;
+  return `${name}: (${ps}) => ${ret}${predPart}`;
 }
 function generalizeAll(source, opts = {}) {
   const file = parseSource(source);
@@ -3849,7 +3598,7 @@ function boundsSatisfiable(bounds) {
         loStrict = true;
       }
     } else if (b.op === "ge") {
-      if (b.n > lo || b.n === lo && loStrict) {
+      if (b.n > lo) {
         lo = b.n;
         loStrict = false;
       }
@@ -3859,7 +3608,7 @@ function boundsSatisfiable(bounds) {
         hiStrict = true;
       }
     } else if (b.op === "le") {
-      if (b.n < hi || b.n === hi && hiStrict) {
+      if (b.n < hi) {
         hi = b.n;
         hiStrict = false;
       }
@@ -4189,281 +3938,6 @@ function isLengthSelf(t) {
   return t.op === "app" && t.fn === "length" && t.args.length === 1 && isSelfVar(t.args[0]);
 }
 
-// src/algebra/bridge.ts
-var confByTv = /* @__PURE__ */ new WeakMap();
-function setTvConfidence(tv, conf) {
-  if (tv && typeof tv === "object") confByTv.set(tv, conf);
-}
-function getTvConfidence(tv) {
-  if (tv && typeof tv === "object") return confByTv.get(tv);
-  return void 0;
-}
-function absToTypeValue(a) {
-  let conf = a.conf;
-  let result;
-  switch (a.shape.k) {
-    case "never":
-      result = T.never;
-      break;
-    case "unknown":
-      if (a.term?.op === "lit" && a.term.value === null) {
-        result = T.literal(null);
-        break;
-      }
-      result = T.unknown;
-      break;
-    case "any":
-      result = T.unknown;
-      break;
-    case "prim": {
-      const lv = litValue(a);
-      if (lv !== void 0) {
-        result = T.literal(lv);
-        break;
-      }
-      if (isTemplateLike(a) && a.shape.k === "prim" && a.shape.type === "string") {
-        const parts = templatePartsOf(a).map(absToTypeValue);
-        result = createTemplate(parts);
-        break;
-      }
-      const prim = primToT(a.shape.type);
-      if (a.pred && a.pred.op !== "true") {
-        const refined = tryEncodeRefined(prim, a);
-        if (refined) {
-          result = refined;
-        } else {
-          result = prim;
-          conf = confJoin(conf, "widened");
-        }
-      } else {
-        result = prim;
-        if (a.term && a.term.op !== "lit") conf = confJoin(conf, "widened");
-      }
-      break;
-    }
-    case "obj": {
-      const props = {};
-      for (const [k, slot] of Object.entries(a.shape.slots)) {
-        let v2 = absToTypeValue(slot.value);
-        if (slot.optional) {
-          v2 = T.union(v2, T.undefined);
-        }
-        props[k] = v2;
-      }
-      result = T.object(props);
-      if (a.shape.open) conf = confJoin(conf, "widened");
-      break;
-    }
-    case "arr":
-      result = T.array(absToTypeValue(a.shape.element));
-      break;
-    case "tuple":
-      result = T.tuple(a.shape.elements.map(absToTypeValue));
-      break;
-    case "fn": {
-      const body = { type: "BlockStatement", body: [], directives: [] };
-      result = T.fn(a.shape.params, body, null);
-      break;
-    }
-    case "brand":
-      result = T.instanceOf(a.shape.name, brandProps(a.shape.shape));
-      break;
-    case "eff":
-      result = T.promise(absToTypeValue(a.shape.inner));
-      break;
-    case "sum":
-      result = T.union(...a.shape.members.map(absToTypeValue));
-      break;
-    default:
-      result = T.unknown;
-      conf = confJoin(conf, "partial");
-  }
-  setTvConfidence(result, conf);
-  return result;
-}
-function primToT(type) {
-  switch (type) {
-    case "number":
-      return T.number;
-    case "string":
-      return T.string;
-    case "boolean":
-      return T.boolean;
-    case "bigint":
-      return T.bigint;
-    case "symbol":
-      return T.symbol;
-    default:
-      return T.unknown;
-  }
-}
-function brandProps(shape2) {
-  if (shape2.shape.k === "obj") {
-    const out = {};
-    for (const [k, slot] of Object.entries(shape2.shape.slots)) {
-      out[k] = absToTypeValue(slot.value);
-    }
-    return out;
-  }
-  return {};
-}
-function tryEncodeRefined(base, a) {
-  if (base.kind !== "primitive" || base.type !== "number") return void 0;
-  const p = a.pred;
-  if (!p) return void 0;
-  if ((p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") && p.b.op === "lit" && typeof p.b.value === "number") {
-    const n = p.b.value;
-    const op = p.op;
-    const check = (value) => {
-      if (typeof value !== "number") return false;
-      switch (op) {
-        case "gt":
-          return value > n;
-        case "ge":
-          return value >= n;
-        case "lt":
-          return value < n;
-        case "le":
-          return value <= n;
-      }
-    };
-    const opSym = op === "gt" ? ">" : op === "ge" ? ">=" : op === "lt" ? "<" : "<=";
-    return T.refine(base, {
-      name: `number (${opSym} ${n})`,
-      meta: { op, n, pred: predToString(p) },
-      check
-    });
-  }
-  return void 0;
-}
-function typeValueToAbs(tv) {
-  if (!tv) return abs({ k: "unknown" }, void 0, void 0, "partial");
-  const confOr = (fallback) => getTvConfidence(tv) ?? fallback;
-  switch (tv.kind) {
-    case "never":
-      return abs({ k: "never" }, void 0, void 0, confOr("exact"));
-    case "unknown":
-      return abs(
-        { k: "unknown" },
-        void 0,
-        void 0,
-        confOr("partial")
-      );
-    case "literal":
-      if (typeof tv.value === "bigint") {
-        return abs(
-          { k: "prim", type: "bigint" },
-          void 0,
-          void 0,
-          confOr("exact")
-        );
-      }
-      return abs(
-        shapeOfLit(tv.value),
-        lit(tv.value),
-        pTrue,
-        confOr("exact")
-      );
-    case "primitive":
-      return abs({ k: "prim", type: tv.type }, void 0, void 0, confOr("exact"));
-    case "refined": {
-      const tplParts = getTemplateParts(tv);
-      if (tplParts) {
-        return createTemplateAbs(tplParts.map(typeValueToAbs));
-      }
-      const base = typeValueToAbs(tv.base);
-      const decoded = tryDecodeRefinedPred(tv, base.term);
-      return abs(
-        base.shape,
-        base.term ?? (decoded ? v("_r") : void 0),
-        decoded ?? base.pred,
-        confOr(confJoin(base.conf, "path"))
-      );
-    }
-    case "object": {
-      const slots = {};
-      for (const [k, v2] of Object.entries(tv.properties)) {
-        slots[k] = { value: typeValueToAbs(v2) };
-      }
-      return abs({ k: "obj", slots }, void 0, void 0, confOr("exact"));
-    }
-    case "array":
-      return abs(
-        { k: "arr", element: typeValueToAbs(tv.element) },
-        void 0,
-        void 0,
-        confOr("exact")
-      );
-    case "tuple":
-      return abs(
-        { k: "tuple", elements: tv.elements.map(typeValueToAbs) },
-        void 0,
-        void 0,
-        confOr("exact")
-      );
-    case "function": {
-      const params = tv.params ?? [];
-      return abs({ k: "fn", params }, void 0, void 0, confOr("exact"));
-    }
-    case "promise":
-      return abs(
-        { k: "eff", eff: "promise", inner: typeValueToAbs(tv.value) },
-        void 0,
-        void 0,
-        confOr("exact")
-      );
-    case "instance": {
-      const slots = {};
-      for (const [k, v2] of Object.entries(tv.properties ?? {})) {
-        slots[k] = { value: typeValueToAbs(v2) };
-      }
-      const inner = abs({ k: "obj", slots }, void 0, void 0, confOr("exact"));
-      return abs(
-        { k: "brand", name: tv.className, shape: inner },
-        void 0,
-        void 0,
-        confOr("exact")
-      );
-    }
-    case "union":
-      return abs(
-        { k: "sum", members: tv.members.map(typeValueToAbs) },
-        void 0,
-        void 0,
-        confOr("path")
-      );
-    default:
-      return abs({ k: "unknown" }, void 0, void 0, confOr("partial"));
-  }
-}
-function tryDecodeRefinedPred(tv, term) {
-  if (tv.kind !== "refined") return void 0;
-  const meta = tv.refinement.meta;
-  const op = meta?.op;
-  const n = meta?.n;
-  if (typeof n !== "number") return void 0;
-  if (op !== "gt" && op !== "ge" && op !== "lt" && op !== "le") return void 0;
-  const t = term ?? v("_r");
-  const b = lit(n);
-  switch (op) {
-    case "gt":
-      return gt(t, b);
-    case "ge":
-      return ge(t, b);
-    case "lt":
-      return lt(t, b);
-    case "le":
-      return le(t, b);
-  }
-}
-function shapeOfLit(v2) {
-  if (typeof v2 === "number") return { k: "prim", type: "number" };
-  if (typeof v2 === "string") return { k: "prim", type: "string" };
-  if (typeof v2 === "boolean") return { k: "prim", type: "boolean" };
-  if (typeof v2 === "bigint") return { k: "prim", type: "bigint" };
-  return { k: "unknown" };
-}
-
 // src/algebra/scan.ts
 function hofFnArgOk(src, tgt) {
   if (src.shape.k !== "fn") return false;
@@ -4475,6 +3949,26 @@ function hofFnArgOk(src, tgt) {
 function listTopFunctions(source, file) {
   const f = file ?? parseSource(source);
   const names = [];
+  const localClasses = /* @__PURE__ */ new Map();
+  for (const stmt of f.program.body) {
+    if (stmt.type === "ClassDeclaration") {
+      const cname = stmt.id?.name;
+      if (cname) localClasses.set(cname, stmt);
+    }
+  }
+  const exportedClassNames = /* @__PURE__ */ new Set();
+  const collectClassMethods = (cname, decl) => {
+    const body = decl.body?.body ?? [];
+    for (const m of body) {
+      const mem = m;
+      const isMethod = mem.type === "MethodDefinition" || mem.type === "ClassMethod" || mem.type === "TSDeclareMethod";
+      if (!isMethod) continue;
+      if (mem.kind && mem.kind !== "method") continue;
+      if (mem.static) continue;
+      const keyName = mem.key?.type === "Identifier" ? mem.key.name : void 0;
+      if (keyName) names.push(`${cname}.${keyName}`);
+    }
+  };
   for (const stmt of f.program.body) {
     let decl = stmt;
     if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
@@ -4491,121 +3985,48 @@ function listTopFunctions(source, file) {
         }
       }
     }
-  }
-  return names;
-}
-function absUnknown() {
-  return { shape: { k: "unknown" }, conf: "partial" };
-}
-function collectParamStructReqs(source, fnName, fileAst) {
-  const reqs = /* @__PURE__ */ new Map();
-  const extracted = extractFn(source, fnName, fileAst);
-  if (!extracted) return reqs;
-  const params = new Set(extracted.params);
-  const body = extracted.body;
-  const BUILTIN_METHODS = /* @__PURE__ */ new Set([
-    "map",
-    "filter",
-    "reduce",
-    "flatMap",
-    "forEach",
-    "some",
-    "every",
-    "find",
-    "findIndex",
-    "includes",
-    "indexOf",
-    "lastIndexOf",
-    "join",
-    "slice",
-    "splice",
-    "push",
-    "pop",
-    "shift",
-    "unshift",
-    "sort",
-    "reverse",
-    "concat",
-    "at",
-    "replace",
-    "replaceAll",
-    "split",
-    "trim",
-    "toLowerCase",
-    "toUpperCase",
-    "startsWith",
-    "endsWith",
-    "charAt",
-    "charCodeAt",
-    "padStart",
-    "padEnd",
-    "repeat",
-    "toString",
-    "valueOf",
-    "substring",
-    "match",
-    "search",
-    "hasOwnProperty",
-    "keys",
-    "values",
-    "entries",
-    "then",
-    "catch",
-    "finally"
-  ]);
-  const visit = (n, isMethodCallee = false, guarded = false) => {
-    if (!n || typeof n !== "object") return;
-    const obj2 = n;
-    if (obj2.type === "LogicalExpression") {
-      visit(obj2.left, false, guarded);
-      visit(obj2.right, false, true);
-      return;
-    }
-    if (obj2.type === "ConditionalExpression") {
-      visit(obj2.test, false, guarded);
-      visit(obj2.consequent, false, true);
-      visit(obj2.alternate, false, true);
-      return;
-    }
-    if (obj2.type === "IfStatement") {
-      visit(obj2.test, false, guarded);
-      visit(obj2.consequent, false, true);
-      visit(obj2.alternate, false, true);
-      return;
+    if (decl.type === "ClassDeclaration" && decl.id?.name && (stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration")) {
+      const cname = decl.id.name;
+      exportedClassNames.add(cname);
+      collectClassMethods(cname, decl);
     }
-    if (obj2.type === "MemberExpression" && !obj2.computed && !isMethodCallee) {
-      const o = obj2.object;
-      const p = obj2.property;
-      if (o?.type === "Identifier" && o.name && params.has(o.name) && p?.type === "Identifier" && p.name) {
-        if (BUILTIN_METHODS.has(p.name)) return;
-        if (guarded) return;
-        let set = reqs.get(o.name);
-        if (!set) {
-          set = /* @__PURE__ */ new Set();
-          reqs.set(o.name, set);
+  }
+  for (const stmt of f.program.body) {
+    if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) {
+      const specs = stmt.specifiers ?? [];
+      for (const spec of specs) {
+        const s = spec;
+        if (s.type !== "ExportSpecifier") continue;
+        const localName = s.local?.name;
+        if (!localName || exportedClassNames.has(localName)) continue;
+        const exportedName = s.exported?.name ?? s.exported?.value;
+        const isDefault = exportedName === "default";
+        if (!isDefault && exportedName !== localName) {
         }
-        set.add(p.name);
+        const decl = localClasses.get(localName);
+        if (!decl) continue;
+        exportedClassNames.add(localName);
+        collectClassMethods(localName, decl);
       }
     }
-    if (obj2.type === "CallExpression") {
-      visit(obj2.callee, true, guarded);
-      for (const key of Object.keys(obj2)) {
-        if (key === "loc" || key === "start" || key === "end" || key === "callee") continue;
-        const val = obj2[key];
-        if (Array.isArray(val)) val.forEach((v2) => visit(v2, false, guarded));
-        else if (val && typeof val === "object") visit(val, false, guarded);
+    if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+      const d = stmt.declaration;
+      if (d.type === "Identifier") {
+        const localName = d.name;
+        if (!exportedClassNames.has(localName)) {
+          const decl = localClasses.get(localName);
+          if (decl) {
+            exportedClassNames.add(localName);
+            collectClassMethods(localName, decl);
+          }
+        }
       }
-      return;
-    }
-    for (const key of Object.keys(obj2)) {
-      if (key === "loc" || key === "start" || key === "end") continue;
-      const val = obj2[key];
-      if (Array.isArray(val)) val.forEach((v2) => visit(v2, isMethodCallee, guarded));
-      else if (val && typeof val === "object") visit(val, isMethodCallee, guarded);
     }
-  };
-  visit(body);
-  return reqs;
+  }
+  return names;
+}
+function absUnknown() {
+  return { shape: { k: "unknown" }, conf: "partial" };
 }
 function evalArgAbs(node, lookupVar) {
   if (node.type === "Identifier" && typeof node.name === "string" && lookupVar) {
@@ -4978,14 +4399,37 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
     eiCache.set(key, r);
     return r;
   };
-  const interfaceToIndexed = (ei, paramNames) => {
+  const projectArgField = (arg, field) => {
+    if (!arg) return void 0;
+    if (arg.shape.k === "brand") {
+      return projectArgField(arg.shape.shape, field);
+    }
+    if (arg.shape.k !== "obj") return void 0;
+    return getSlot(arg.shape.slots, field)?.value;
+  };
+  const interfaceToIndexed = (ei, paramNames, formals) => {
     const conflict = new Set(ei.conflict?.params ?? []);
     const entries = [];
     for (const { param, constraint } of ei.params) {
-      if (conflict.has(param)) continue;
+      if (!param || conflict.has(param)) continue;
       const idx = paramNames.indexOf(param);
       if (idx >= 0) {
-        entries.push([idx, { param, pred: instantiateConstraint(constraint, param), constraint }]);
+        entries.push([
+          idx,
+          { param, pred: instantiateConstraint(constraint, param), constraint },
+          void 0
+        ]);
+        continue;
+      }
+      if (formals && formals.length > 0) {
+        const hit = locateContractParam(formals, param);
+        if (hit) {
+          entries.push([
+            hit.index,
+            { param, pred: instantiateConstraint(constraint, param), constraint },
+            hit.field
+          ]);
+        }
       }
     }
     return entries;
@@ -5019,15 +4463,36 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
     return lv <= n;
   };
   const checkReqs = (displayName, reqs, paramNames, absArgs, argIndexOf, loc) => {
-    for (const [idx, pred] of reqs) {
+    for (const [idx, pred, field, contractParam] of reqs) {
       const argIdx = argIndexOf(idx);
       if (argIdx === void 0) continue;
-      const arg = absArgs[argIdx];
+      let arg = absArgs[argIdx];
       if (!arg) continue;
+      const paramName = contractParam || paramNames[idx] || `arg${idx}`;
+      if (field) {
+        const projected = projectArgField(arg, field);
+        if (!projected) {
+          const k = arg.shape.k;
+          if (k !== "unknown" && k !== "any") {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+              actual: formatAbs(arg),
+              expected: `missing field ${field}`,
+              suggestion: `\u8865\u5168\u5B57\u6BB5 ${field}`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+          continue;
+        }
+        arg = projected;
+      }
       const lv = litValue(arg);
       const isStr = arg.shape.k === "prim" && arg.shape.type === "string";
       const strLen = typeof lv === "string" ? lv.length : void 0;
-      const paramName = paramNames[idx] ?? `arg${idx}`;
       for (const p of flattenPred(pred)) {
         if (p.op === "typeof") {
           if (p.t.op !== "var") continue;
@@ -5104,14 +4569,13 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
             if (p.op === "lt") ok2 = strLen < n;
             if (p.op === "le") ok2 = strLen <= n;
             if (!ok2) {
-              const paramName2 = paramNames[idx] ?? `arg${idx}`;
               out.push({
                 severity: "error",
                 code: "nudo:constraint-violated",
-                message: `${displayName}[${paramName2}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+                message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
                 actual: formatAbs(arg),
-                expected: `length(${paramName2}) ${opSym} ${n}`,
-                suggestion: `\u6539\u7528\u6EE1\u8DB3\u957F\u5EA6 ${opSym} ${n} \u7684\u503C\uFF0C\u6216\u653E\u5BBD ${paramName2} \u7684\u524D\u7F6E`,
+                expected: `length(${paramName}) ${opSym} ${n}`,
+                suggestion: `\u6539\u7528\u6EE1\u8DB3\u957F\u5EA6 ${opSym} ${n} \u7684\u503C\uFF0C\u6216\u653E\u5BBD ${paramName} \u7684\u524D\u7F6E`,
                 fn: displayName,
                 line: loc?.start.line,
                 column: loc?.start.column
@@ -5126,14 +4590,13 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
           if (p.op === "lt") ok = lv < n;
           if (p.op === "le") ok = lv <= n;
           if (!ok) {
-            const paramName2 = paramNames[idx] ?? `arg${idx}`;
             out.push({
               severity: "error",
               code: "nudo:constraint-violated",
-              message: `${displayName}[${paramName2}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+              message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
               actual: formatAbs(arg),
               expected: predToString(p),
-              suggestion: `\u6539\u7528\u6EE1\u8DB3 ${predToString(p)} \u7684\u503C\uFF0C\u6216\u653E\u5BBD ${paramName2} \u7684\u524D\u7F6E`,
+              suggestion: `\u6539\u7528\u6EE1\u8DB3 ${predToString(p)} \u7684\u503C\uFF0C\u6216\u653E\u5BBD ${paramName} \u7684\u524D\u7F6E`,
               fn: displayName,
               line: loc?.start.line,
               column: loc?.start.column
@@ -5315,14 +4778,35 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
     }
   };
   const checkShapeReqs = (displayName, reqs, paramNames, absArgs, argIndexOf, loc) => {
-    for (const [idx, entry] of reqs) {
+    for (const [idx, entry, field] of reqs) {
       const c = entry.constraint;
       if (!c.fields && !c.element && !isIntFlag(c) && !c.prim) continue;
       const argIdx = argIndexOf(idx);
       if (argIdx === void 0) continue;
-      const arg = absArgs[argIdx];
+      let arg = absArgs[argIdx];
       if (!arg) continue;
       const paramName = entry.param || paramNames[idx] || `arg${idx}`;
+      if (field) {
+        const projected = projectArgField(arg, field);
+        if (!projected) {
+          const k = arg.shape.k;
+          if (k !== "unknown" && k !== "any") {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+              actual: formatAbs(arg),
+              expected: `missing field ${field}`,
+              suggestion: `\u8865\u5168\u5B57\u6BB5 ${field}`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+          continue;
+        }
+        arg = projected;
+      }
       if (c.fields) {
         checkShapeAgainstAbs(displayName, paramName, c, arg, paramName, loc);
       }
@@ -5437,11 +4921,11 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
     };
     const ownEi = effectiveInterfaceOf(fnName, source, optsR);
     if (ownEi?.source === "handwritten") {
-      const ownFull = interfaceToIndexed(ownEi, paramNames);
+      const ownFull = interfaceToIndexed(ownEi, paramNames, g?.formals);
       checkShapeReqs(fnName, ownFull, paramNames, absArgs, (i) => i, loc);
       checkReqs(
         fnName,
-        ownFull.map(([i, e]) => [i, e.pred]),
+        ownFull.map(([i, e, f]) => [i, e.pred, f, e.param]),
         paramNames,
         absArgs,
         (i) => i,
@@ -5453,7 +4937,7 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
       const tg = generalizeFromAst(fwd.target, source, file ? { file } : {});
       const tParams = tg?.params ?? [];
       const tEi = effectiveInterfaceOf(fwd.target, source, optsR);
-      const tFull = tEi?.source === "handwritten" ? interfaceToIndexed(tEi, tParams) : [];
+      const tFull = tEi?.source === "handwritten" ? interfaceToIndexed(tEi, tParams, tg?.formals) : [];
       if (tFull.length > 0) {
         const wrapperArgOfTarget = /* @__PURE__ */ new Map();
         fwd.map.forEach((wrapperIdx, targetIdx) => {
@@ -5463,7 +4947,7 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
         checkShapeReqs(`${fnName}\u2192${fwd.target}`, tFull, tParams, absArgs, mapArg, loc);
         checkReqs(
           `${fnName}\u2192${fwd.target}`,
-          tFull.map(([i, e]) => [i, e.pred]),
+          tFull.map(([i, e, f]) => [i, e.pred, f, e.param]),
           tParams,
           absArgs,
           mapArg,
@@ -5489,7 +4973,7 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
       };
       const ei = effectiveInterfaceOf(ext.fnName, ext.source, eiOpts);
       if (ei?.source === "handwritten") {
-        full = interfaceToIndexed(ei, paramNames);
+        full = interfaceToIndexed(ei, paramNames, g?.formals);
       }
     } catch {
       out.push({
@@ -5505,7 +4989,7 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
     checkShapeReqs(displayName, full, paramNames, absArgs, (i) => i, loc);
     checkReqs(
       displayName,
-      full.map(([i, e]) => [i, e.pred]),
+      full.map(([i, e, f]) => [i, e.pred, f, e.param]),
       paramNames,
       absArgs,
       (i) => i,
@@ -5549,19 +5033,15 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
       }
     }
   };
-  const checkArgStructures = (fnName, fnSource, args, loc, displayName, interfaceFromFile) => {
-    let structReqs;
-    let paramNames;
+  const checkArgStructures = (fnName, fnSource, args, loc, displayName, _interfaceFromFile) => {
     let gFn;
     try {
       const sameFile = fnSource === source;
-      structReqs = collectParamStructReqs(fnSource, fnName, sameFile ? file : void 0);
       gFn = generalizeFromAst(
         fnName,
         fnSource,
         sameFile && file ? { file } : {}
       );
-      paramNames = gFn?.params ?? [];
     } catch (e) {
       out.push({
         severity: "warning",
@@ -5582,65 +5062,6 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
         (n) => evalArgAbs(n, (x) => varAbs.get(x))
       );
     }
-    if (structReqs.size === 0) return;
-    let refinedParams;
-    try {
-      const sameFile = fnSource === source;
-      const eiOpts = sameFile ? {
-        loadModule: opts?.loadModule,
-        fromFile: opts?.fromFile ?? "",
-        ...opts?.autoBind !== void 0 ? { autoBind: opts.autoBind } : {}
-      } : {
-        loadModule: opts?.loadModule,
-        fromFile: interfaceFromFile ?? opts?.fromFile ?? "",
-        ...interfaceFromFile ? opts?.autoBind !== void 0 ? { autoBind: opts.autoBind } : {} : { autoBind: false }
-      };
-      const ei = effectiveInterfaceOf(fnName, fnSource, eiOpts);
-      if (ei?.source === "handwritten" && ei.params.length > 0) {
-        refinedParams = new Set(ei.params.map((p) => p.param));
-      }
-    } catch {
-      out.push({
-        severity: "warning",
-        code: "nudo:no-signature",
-        message: `${displayName ?? fnName}: handwritten interface load failed; falling back to body structure inference`,
-        fn: displayName ?? fnName,
-        line: loc?.start.line,
-        column: loc?.start.column
-      });
-    }
-    for (let i = 0; i < args.length; i++) {
-      const pname = paramNames[i];
-      if (!pname) continue;
-      if (refinedParams?.has(pname)) continue;
-      const keys = structReqs.get(pname);
-      if (!keys || keys.size === 0) continue;
-      const argNode = args[i];
-      if (!argNode) continue;
-      const absArg = evalArgAbs(argNode, (n) => varAbs.get(n));
-      if (!absArg || absArg.shape.k === "unknown") continue;
-      const isLeny = absArg.shape.k === "arr" || absArg.shape.k === "tuple" || absArg.shape.k === "prim" && absArg.shape.type === "string";
-      const needKeys = isLeny ? [...keys].filter((k) => k !== "length") : [...keys];
-      if (needKeys.length === 0) continue;
-      const slots = {};
-      for (const k of needKeys) slots[k] = { value: absUnknown() };
-      const target = abs({ k: "obj", slots }, void 0, void 0, "exact");
-      const leq = leqAbs(absArg, target);
-      if (!leq.ok) {
-        const name = displayName ?? fnName;
-        out.push({
-          severity: "error",
-          code: "nudo:arg-structure",
-          message: `${name}[${pname}]: \u5B9E\u53C2\u7ED3\u6784 \u22AD \u5F62\u53C2`,
-          actual: formatAbs(absArg),
-          expected: formatAbs(target),
-          suggestion: leq.reason ?? `\u8865\u5168 ${pname} \u4E0A\u88AB\u8BBF\u95EE\u7684\u5B57\u6BB5`,
-          fn: name,
-          line: loc?.start.line,
-          column: loc?.start.column
-        });
-      }
-    }
   };
   const visit = (n) => {
     if (!n || typeof n !== "object") return;
@@ -5670,9 +5091,13 @@ function evidenceToString(v2) {
   return typeof v2 === "string" ? JSON.stringify(v2) : String(v2);
 }
 function checkInjectedDomainEvidence(fnName, source, records, opts) {
-  const usable = records.filter(
-    (r) => !(r.resultType?.kind === "never" && r.throws?.kind === "never")
-  );
+  const isLeaked = (r) => {
+    if (r.resultAbs && r.throwsAbs) {
+      return r.resultAbs.shape.k === "never" && r.throwsAbs.shape.k === "never";
+    }
+    return false;
+  };
+  const usable = records.filter((r) => !isLeaked(r));
   if (usable.length === 0) return [];
   let ei;
   try {
@@ -5701,15 +5126,9 @@ function checkInjectedDomainEvidence(fnName, source, records, opts) {
     if (idx < 0) continue;
     const failures = [];
     for (const rec of usable) {
-      const arg = rec.argTypes[idx];
-      if (!arg || arg.kind !== "literal") continue;
-      const v2 = arg.value;
-      if (typeof v2 !== "number" && typeof v2 !== "string" && typeof v2 !== "boolean") {
-        continue;
-      }
-      const conf = getTvConfidence(arg);
-      if (conf !== void 0 && conf !== "exact" && conf !== "path") continue;
-      if (!literalMeetsConstraint(v2, constraint)) failures.push(v2);
+      const lit3 = extractLiteralEvidence(rec, idx);
+      if (lit3 === void 0) continue;
+      if (!literalMeetsConstraint(lit3, constraint)) failures.push(lit3);
     }
     if (failures.length === 0) continue;
     const shown = [...new Set(failures)].map(evidenceToString).join(", ");
@@ -5727,8 +5146,26 @@ function checkInjectedDomainEvidence(fnName, source, records, opts) {
   }
   return out;
 }
+function extractLiteralEvidence(rec, idx) {
+  const absArg = rec.argAbs?.[idx];
+  if (!absArg) return void 0;
+  if (absArg.conf !== "exact" && absArg.conf !== "path") return void 0;
+  const lv = litValue(absArg);
+  if (typeof lv === "number" || typeof lv === "string" || typeof lv === "boolean") {
+    return lv;
+  }
+  return void 0;
+}
 
 // src/algebra/check.ts
+function projectCaseArgField(arg, field) {
+  if (!arg) return void 0;
+  if (arg.shape.k === "brand") {
+    return projectCaseArgField(arg.shape.shape, field);
+  }
+  if (arg.shape.k !== "obj") return void 0;
+  return getSlot(arg.shape.slots, field)?.value;
+}
 var checkReportMemo = /* @__PURE__ */ new Map();
 var checkKeyDeps = /* @__PURE__ */ new Map();
 var checkDepIndex = /* @__PURE__ */ new Map();
@@ -5752,7 +5189,7 @@ function loadModuleId2(fn2) {
 }
 function checkDepsFingerprint(source, opts) {
   if (!opts.loadModule || !opts.fromFile) {
-    return { fp: "-", paths: [], truncated: false };
+    return { fp: "-", paths: [], contents: [], truncated: false };
   }
   return loadModuleDepsFingerprint(source, opts.loadModule, opts.fromFile);
 }
@@ -5799,7 +5236,8 @@ function checkMemoKey(filePath, source, identityOpts, deps, sidecarFp) {
     filePath,
     `${loadModuleId2(identityOpts.loadModule)}:${identityOpts.fromFile ?? ""}`,
     deps.fp,
-    sidecarFp ?? "-"
+    sidecarFp ?? "-",
+    identityOpts.autoBind === false ? "ab0" : "ab1"
   ].join("|");
 }
 function checkMemoGet(key) {
@@ -5972,6 +5410,26 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
     });
     if (hasRefineDirective || (exportedNames?.has(name) ?? false)) {
       const eff = effectiveInterfaceCached(name);
+      if (eff?.source === "handwritten") {
+        const contractNames = contractParamNameSet(g.formals ?? []);
+        const formalDisplay = new Set(g.params);
+        const conflictNames = new Set(eff.conflict?.params ?? []);
+        const unknownParams = eff.params.map((p) => p.param).filter(
+          (p) => p && !formalDisplay.has(p) && !contractNames.has(p) && !conflictNames.has(p)
+        );
+        if (unknownParams.length > 0) {
+          const surface = [...contractNames].filter((n) => !n.startsWith("_p") && n !== "_").join(", ");
+          issues.push({
+            severity: "error",
+            code: "nudo:interface-param-mismatch",
+            message: `${name}: \u5951\u7EA6\u53C2\u6570\u540D\u4E0D\u5728\u5F62\u53C2\u8868\uFF08${unknownParams.join(", ")}\uFF09`,
+            actual: unknownParams.join(", "),
+            expected: surface || g.params.join(", ") || "(\u65E0\u53C2)",
+            suggestion: `\u628A @nudo:refine / \u4FA7\u8F66\u7ED1\u5B9A\u53C2\u6570\u540D\u6539\u6210\u5F62\u53C2\u4E4B\u4E00\uFF1A${surface || g.params.join(", ") || "\uFF08\u51FD\u6570\u65E0\u53C2\uFF09"}`,
+            fn: name
+          });
+        }
+      }
       if (eff?.conflict) {
         if (eff.conflict.params.length > 0) {
           issues.push({
@@ -6046,14 +5504,14 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
   const varAbs = /* @__PURE__ */ new Map();
   const callRecords = [];
   setAbsAssignCollector((r) => records.push(r));
-  setAbsCallCollector((r) => callRecords.push(r));
+  const prevCallCollector = setAbsCallCollector((r) => callRecords.push(r));
   try {
     const { env } = evalProgramAbs(source, { file });
     for (const [k, v2] of env.vars) varAbs.set(k, v2);
   } catch {
   } finally {
     setAbsAssignCollector(null);
-    setAbsCallCollector(null);
+    setAbsCallCollector(prevCallCollector);
   }
   const callIssues = canSkipLiteralCallScan(source, file) ? [] : scanLiteralCalls(source, names, phi, {
     loadModule: opts.loadModule,
@@ -6301,10 +5759,19 @@ function scanCaseInconsistency(source, knownFns, opts) {
     });
     if (!eff || eff.source !== "handwritten") return;
     const conflictParams = new Set(eff.conflict?.params ?? []);
+    const formals = g.formals ?? [];
     const reqs = [];
     for (const p of eff.params) {
       if (conflictParams.has(p.param)) continue;
-      const idx = paramNames.indexOf(p.param);
+      let idx = paramNames.indexOf(p.param);
+      let field;
+      if (idx < 0 && formals.length > 0) {
+        const hit = locateContractParam(formals, p.param);
+        if (hit) {
+          idx = hit.index;
+          field = hit.field;
+        }
+      }
       if (idx < 0) continue;
       reqs.push([
         idx,
@@ -6312,15 +5779,40 @@ function scanCaseInconsistency(source, knownFns, opts) {
           param: p.param,
           pred: instantiateConstraint(p.constraint, p.param),
           constraint: p.constraint
-        }
+        },
+        field
       ]);
     }
     if (reqs.length === 0) return;
     const absArgs = args.map((a) => parseLitArg(a) ?? absUnknown());
-    for (const [idx, entry] of reqs) {
+    for (const req of reqs) {
+      const idx = req[0];
+      const entry = req[1];
+      const field = req[2];
       if (entry.constraint.fields) continue;
-      const arg = absArgs[idx];
+      let arg = absArgs[idx];
       if (!arg) continue;
+      if (field) {
+        const projected = projectCaseArgField(arg, field);
+        if (!projected) {
+          const k = arg.shape.k;
+          if (k !== "unknown" && k !== "any") {
+            const paramName = entry.param || paramNames[idx] || `arg${idx}`;
+            out.push({
+              severity: "error",
+              code: "nudo:case-inconsistency",
+              message: `${fnName} case "${caseName}": \u89C1\u8BC1 \u22AD \u5951\u7EA6`,
+              actual: formatAbs(arg),
+              expected: `missing field ${field}`,
+              suggestion: `case \u5B9E\u53C2\u8865\u5168\u5B57\u6BB5 ${field}\uFF08\u5951\u7EA6\u4F4D ${paramName}\uFF09`,
+              fn: fnName,
+              line
+            });
+          }
+          continue;
+        }
+        arg = projected;
+      }
       const lv = litValue(arg);
       if (lv === void 0 || typeof lv !== "number" && typeof lv !== "string" && typeof lv !== "boolean") {
         continue;
@@ -6619,8 +6111,12 @@ function formatReturnDisplay(g) {
   }
   return memberPath(abs2).text;
 }
-function collectAbsInlays(source, refineOpts) {
+function collectAbsInlays(source, opts) {
   const inlays = [];
+  const refineOpts = opts?.loadModule || opts?.fromFile ? {
+    ...opts.loadModule ? { loadModule: opts.loadModule } : {},
+    ...opts.fromFile ? { fromFile: opts.fromFile } : {}
+  } : void 0;
   for (const { name, node } of listFunctions(source)) {
     let g;
     try {
@@ -6629,6 +6125,12 @@ function collectAbsInlays(source, refineOpts) {
       continue;
     }
     if (!g) continue;
+    const tier = opts?.fromFile !== void 0 ? interfaceTierOf(source, name, opts.fromFile, {
+      ...opts.loadModule ? { loadModule: opts.loadModule } : {},
+      ...opts.autoBind !== void 0 ? { autoBind: opts.autoBind } : {}
+    }) : void 0;
+    const tierSrc = tier?.source;
+    const isImplicitExport = tierSrc === "implicit";
     const params = g.params;
     const predsByName = /* @__PURE__ */ new Map();
     if (g.entryReqs) {
@@ -6649,7 +6151,8 @@ function collectAbsInlays(source, refineOpts) {
           line: p.loc.end.line,
           character: p.loc.end.column,
           label: `  where ${text}`,
-          kind: "parameter"
+          kind: "parameter",
+          ...tierSrc ? { interfaceSource: tierSrc } : {}
         });
       }
     }
@@ -6661,11 +6164,14 @@ function collectAbsInlays(source, refineOpts) {
       } catch {
         label = `: ${formatShape(g.symbolic)}`;
       }
+      if (isImplicitExport) label += "  \xB7 derived";
       inlays.push({
         line: bodyLoc.start.line,
         character: Math.max(0, bodyLoc.start.column),
         label: `${label}  `,
-        kind: "type"
+        kind: "type",
+        ...tierSrc ? { interfaceSource: tierSrc } : {},
+        ...isImplicitExport ? { derived: true } : {}
       });
     }
   }
@@ -6676,7 +6182,7 @@ function collectAbsInlays(source, refineOpts) {
 function denoteGuard(a, v2) {
   const lv = litValue(a);
   if (lv !== void 0 && (!a.pred || a.pred.op === "true")) {
-    return `${v2} === ${JSON.stringify(lv)}`;
+    return eqGuard(v2, lv);
   }
   const shape2 = denoteShape(a.shape, v2);
   const pred = denotePred(a, v2);
@@ -6755,7 +6261,7 @@ function denotePred(a, v2) {
   const p = a.pred;
   if (!p || p.op === "true") {
     const lv = litValue(a);
-    if (lv !== void 0) return `${v2} === ${JSON.stringify(lv)}`;
+    if (lv !== void 0) return eqGuard(v2, lv);
     return "true";
   }
   return predAsJs(p, v2, a);
@@ -6784,15 +6290,15 @@ function predAsJs(p, v2, a) {
       const leftIsValue = termIsValue(p.a, a);
       const rightLit = litOfTerm(p.b);
       if (leftIsValue && rightLit !== void 0) {
-        return `${v2} ${op} ${JSON.stringify(rightLit)}`;
+        return cmpOp(v2, op, rightLit);
       }
       const leftLit = litOfTerm(p.a);
       const rightIsValue = termIsValue(p.b, a);
       if (rightIsValue && leftLit !== void 0) {
-        return `${JSON.stringify(leftLit)} ${op} ${v2}`;
+        return cmpLitValue(leftLit, op, v2);
       }
       if (leftLit !== void 0 && rightLit !== void 0) {
-        return `${JSON.stringify(leftLit)} ${op} ${JSON.stringify(rightLit)}`;
+        return `${jsLit(leftLit)} ${op} ${jsLit(rightLit)}`;
       }
       return "true";
     }
@@ -6803,6 +6309,35 @@ function predAsJs(p, v2, a) {
 function litOfTerm(t) {
   return t.op === "lit" ? t.value : void 0;
 }
+function jsLit(v2) {
+  if (v2 === void 0) return "undefined";
+  if (v2 === null) return "null";
+  if (typeof v2 === "number") {
+    if (Number.isNaN(v2)) return "NaN";
+    if (v2 === Infinity) return "Infinity";
+    if (v2 === -Infinity) return "-Infinity";
+    return String(v2);
+  }
+  return JSON.stringify(v2);
+}
+function eqGuard(v2, lv) {
+  if (typeof lv === "number" && Number.isNaN(lv)) return `Number.isNaN(${v2})`;
+  return `${v2} === ${jsLit(lv)}`;
+}
+function cmpOp(v2, op, lit3) {
+  if (typeof lit3 === "number" && Number.isNaN(lit3)) {
+    if (op === "===") return `Number.isNaN(${v2})`;
+    if (op === "!==") return `!Number.isNaN(${v2})`;
+  }
+  return `${v2} ${op} ${jsLit(lit3)}`;
+}
+function cmpLitValue(lit3, op, v2) {
+  if (typeof lit3 === "number" && Number.isNaN(lit3)) {
+    if (op === "===") return `Number.isNaN(${v2})`;
+    if (op === "!==") return `!Number.isNaN(${v2})`;
+  }
+  return `${jsLit(lit3)} ${op} ${v2}`;
+}
 function termIsValue(t, a) {
   if (t.op === "var") return true;
   if (t.op === "lit") {
@@ -6814,6 +6349,8 @@ function termIsValue(t, a) {
 export {
   $add,
   $arr,
+  $arrMutContainer,
+  $arrRest,
   $async,
   $asyncReturn,
   $await,
@@ -6825,6 +6362,7 @@ export {
   $div,
   $elems,
   $eq,
+  $eqLoose,
   $fnVal,
   $for,
   $forIter,
@@ -6838,22 +6376,29 @@ export {
   $idxSet,
   $invoke,
   $invokeSuper,
+  $isForkExit,
   $join,
   $le,
   $len,
   $lit,
+  $loopReturn,
   $lt,
   $mod,
   $mul,
   $ne,
+  $neLoose,
   $neg,
   $new,
   $not,
+  $nullishTest,
   $obj,
+  $objRest,
   $optionalGet,
   $optionalInvoke,
   $orDefault,
+  $pushLoopExit,
   $regex,
+  $rethrowIfNudoReturn,
   $set,
   $setKey,
   $spread,
@@ -6864,6 +6409,10 @@ export {
   $thisGet,
   $thisSet,
   $throw,
+  $tryCurrentMark,
+  $tryMark,
+  $tryPopMark,
+  $tryTakeSince,
   $typeof,
   $while,
   $whileSeq,
@@ -6871,32 +6420,35 @@ export {
   DEFAULT_MAX_LOOP_ITERS,
   MAX_CALL_DEPTH,
   MAX_TOTAL_CALLS,
+  NudoReturn,
   NudoSidecarError,
   NudoThrow,
-  Ops,
   SELF,
-  T,
+  abortDerivationSession,
   abs,
   absFunction,
+  absShapeKey,
   absTemplateViews,
   absToConstraint,
   absToString,
-  absToTypeValue,
   add,
   allFixedTextOfViews,
   alphaOf,
   analyzeFn,
+  analyzeFnFull,
   and,
+  any,
   anyVar,
   app,
   applyAbsFn,
-  applyBinaryOp,
   applyCallbackAbs,
   array,
   asAbs,
   asAbsVal,
   attachFnImpl,
   awaitAbs,
+  beginCollectionFork,
+  beginDerivationSession,
   betaOf,
   bindImports,
   bool,
@@ -6904,7 +6456,9 @@ export {
   boolean,
   buildArgsFromAssume,
   callAbsMethod,
+  callAtFunctionBoundary,
   callFunction,
+  callFunctionFull,
   callTranspiledExport,
   callTranspiledExportFull,
   canSkipLiteralCallScan,
@@ -6914,40 +6468,41 @@ export {
   checkSource,
   classFromMethods,
   clearBClasses,
+  clearCollectionTables,
   cmp,
   coerceAsyncReturn,
-  collapseLiteralUnion,
   collectAbsExports,
+  collectAbsFreeVars,
   collectAbsInlays,
   collectAbsNodeTypes,
+  collectionElementJoin,
+  collectionExactLen,
   concatString,
-  concatTemplates,
   confJoin,
   constraintToEntryAbs,
+  contractParamNameSet,
   createEnvironment,
   createHofCollectCtx,
-  createRange,
-  createTemplate,
   createTemplateAbs,
   currentExecPhi,
   currentPhi,
   decideEndsWith,
   decideIncludes,
   decideStartsWith,
-  deepCloneTypeValue,
   defaultLeakBudget,
   defineClass,
   definitelyNotNullishShape,
   denoteGuard,
+  derivationChain,
   describePhi,
-  dispatchBinaryOp,
-  dispatchMethod,
-  dispatchProperty,
   div,
   effectiveInterface,
   emptyEnv,
   emptyPhi,
+  endCollectionFork,
+  endDerivationSession,
   eq,
+  errorBrandAbs,
   evalArrayStatic,
   evalBuiltinInstanceMethod,
   evalBuiltinNew,
@@ -6984,11 +6539,15 @@ export {
   fnConstraintToEntryReqs,
   fnFingerprints,
   fnOf,
+  formalParamDisplayNames,
+  formalParamsFromNodes,
   formatAbs,
   formatAbsMultiline,
   formatCheckReport,
   formatConstraint,
   formatDiagnostics,
+  formatEffectiveInterfaceDisplay,
+  formatInterfaceTierLine,
   formatShape,
   formatShapeSlot,
   formatTemplateNameViews,
@@ -7004,20 +6563,16 @@ export {
   getBClass,
   getClass,
   getClassChain,
+  getDerivation,
   getFnImpl,
   getFnNameAndBodies,
-  getFnSig,
   getGeneralizeMemoSize,
   getParseSourceCacheSize,
-  getPrimitiveTypeOf,
-  getRangeMeta,
-  getRefinedBase,
   getSlot,
-  getTemplateParts,
   getTerm,
-  getTvConfidence,
   gt,
   gtNum,
+  hasDerivationSession,
   hashSource,
   implies,
   instanceOf,
@@ -7025,22 +6580,26 @@ export {
   instantiateConstraint,
   instantiateReturn,
   interfaceDiagCount,
+  interfaceSourceOf,
+  interfaceTierOf,
+  isArrMutator,
   isDefinitelyFalse,
   isDefinitelyTrue,
+  isErrorCtorName,
+  isEvalMissingSlotEnabled,
   isExactLit,
-  isFnSig,
   isIntFlag,
+  isMapAbs,
   isNodeModulesPath,
   isNudoConstraint,
+  isNudoReturn,
   isNudoThrow,
   isNullishLitAbs,
   isNumPrim,
   isObj,
-  isRange,
   isRelFn,
+  isSetAbs,
   isStrPrim,
-  isSubtypeOf,
-  isTemplate,
   isTemplateLike,
   joinAbs,
   joinFunctions,
@@ -7061,30 +6620,44 @@ export {
   literalMeetsConstraint,
   loadModuleDepsFingerprint,
   localNamedExports,
+  locateContractParam,
   lookupMethod,
   lookupMethodWithOwner,
   lookupSuperMethod,
+  looseEqAbs,
   lt,
   ltNum,
+  makeMapAbs,
+  makeSetAbs,
   makeSum,
+  mapClearEntries,
+  mapDeleteEntry,
   mapElementFallback,
+  mapEntriesAbs,
+  mapGetEntry,
+  mapHasEntry,
+  mapSetEntry,
+  mapSizeAbs,
+  mapValuesAbs,
   matchRelIdentLit,
   maybeLeak,
   mergeAdjacentFixedViews,
-  mergeObjectProperties,
+  mergeCollectionArms,
   mock,
-  mockHelperToTypeValue,
   mod,
   mul,
   namespaceNameOf,
-  narrowType,
   ne,
   negAbs,
   never,
   normPath,
   not,
   notAbs,
+  noteCollectionWrite,
+  noteDerivationAdd,
+  noteDerivationJoin,
   noteMemberDispatchMiss,
+  noteObjSlotMissing,
   notePrimMemberMissing,
   noteUnknownMemberMissing,
   num,
@@ -7101,15 +6674,20 @@ export {
   partial,
   phiAnd,
   pick,
+  popCollectionArm,
   popPhi,
   predEquals,
   predToString,
   predVars,
   projectBrand,
+  projectDerivationDsl,
   projectFlatMapResult,
   promoteParamShape,
   ptypeof,
+  pushCollectionArm,
+  pushLoopExit,
   pushPhi,
+  pushThrowExit,
   recordMemberDiag,
   refineAbsForRelTrue,
   refineDiagCount,
@@ -7128,17 +6706,27 @@ export {
   resetPhi,
   resolveDepPath,
   runTranspiled,
+  runWithEvalMissingSlot,
+  runWithLoopExits,
   serializeCheckJson,
   setAbsAssignCollector,
   setAbsCallCollector,
   setAbsNodeCollector,
   setAbsTruncationCollector,
+  setAddEntry,
   setApplyCallbackHost,
   setBCallCollector,
+  setClearEntries,
+  setDeleteEntry,
+  setDerivation,
+  setDerivationCollector,
+  setElementsAbs,
+  setEvalMissingSlotEnabled,
+  setHasEntry,
   setInterfaceDiagCollector,
   setMemberDiagCollector,
   setRefineDiagCollector,
-  setTvConfidence,
+  setSizeAbs,
   shape,
   shapeOfTerm,
   shapeOnlyFn,
@@ -7147,7 +6735,6 @@ export {
   sidecarPathOf,
   sidecarSpecsOf,
   simplifyTerm,
-  simplifyUnion,
   snapshotAbs,
   spread,
   spy,
@@ -7162,17 +6749,20 @@ export {
   substAbs,
   substPred,
   substPredAbs,
-  subtractType,
   superNameOf,
   tagAbsOrigin,
+  tagDerivationRoot,
   takeInterfaceDiags,
   takeInterfaceDiagsSince,
+  takeLoopExits,
   takeRefineDiags,
   takeRefineDiagsSince,
+  takeThrowExits,
   templateMatchesValue,
   templatePartsOf,
   termDepth,
   termEquals,
+  termKey,
   termNodes,
   termToString,
   transpile,
@@ -7184,16 +6774,12 @@ export {
   tryPromoteForOfIteratee,
   tryPromoteHofCallback,
   tryPromoteReceiverAsArr,
-  typeValueEquals,
-  typeValueToAbs,
-  typeValueToString,
   typeofAbs,
   undefAbs,
   union,
   unknown,
   v,
   viewTemplateParts,
-  widenLiteral,
   withExecPhi,
   withPhiConstraint,
   withVar,