@nudojs/core 1.0.1 → 2.0.1

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,6 +72,7 @@ import {
   DEFAULT_MAX_LOOP_ITERS,
   MAX_CALL_DEPTH,
   MAX_TOTAL_CALLS,
+  NudoReturn,
   NudoThrow,
   abortDerivationSession,
   abs,
@@ -79,22 +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,
@@ -110,8 +130,10 @@ import {
   div,
   emptyEnv,
   emptyPhi,
+  endCollectionFork,
   endDerivationSession,
   eq,
+  errorBrandAbs,
   evalArrayStatic,
   evalBuiltinInstanceMethod,
   evalBuiltinNew,
@@ -157,14 +179,20 @@ import {
   instanceOf,
   instantiateClass,
   instantiateReturn,
+  isArrMutator,
   isDefinitelyFalse,
   isDefinitelyTrue,
+  isErrorCtorName,
+  isEvalMissingSlotEnabled,
   isExactLit,
+  isMapAbs,
+  isNudoReturn,
   isNudoThrow,
   isNullishLitAbs,
   isNumPrim,
   isObj,
   isRelFn,
+  isSetAbs,
   isStrPrim,
   isTemplateLike,
   joinAbs,
@@ -183,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,
@@ -198,9 +238,11 @@ import {
   never,
   not,
   notAbs,
+  noteCollectionWrite,
   noteDerivationAdd,
   noteDerivationJoin,
   noteMemberDispatchMiss,
+  noteObjSlotMissing,
   notePrimMemberMissing,
   noteUnknownMemberMissing,
   num,
@@ -213,6 +255,7 @@ import {
   pTrue,
   parseSource,
   phiAnd,
+  popCollectionArm,
   predEquals,
   predToString,
   predVars,
@@ -221,24 +264,37 @@ import {
   projectFlatMapResult,
   promoteParamShape,
   ptypeof,
+  pushCollectionArm,
+  pushLoopExit,
+  pushThrowExit,
   recordMemberDiag,
   refineAbsForRelTrue,
   registerBClass,
   relationFingerprint,
   relationFn,
+  requiredFnArity,
   resetAbsCallBudget,
   resetLeakCounter,
   resetParseSourceCache,
   runTranspiled,
+  runWithEvalMissingSlot,
+  runWithLoopExits,
   setAbsAssignCollector,
   setAbsCallCollector,
   setAbsNodeCollector,
   setAbsTruncationCollector,
+  setAddEntry,
   setApplyCallbackHost,
   setBCallCollector,
+  setClearEntries,
+  setDeleteEntry,
   setDerivation,
   setDerivationCollector,
+  setElementsAbs,
+  setEvalMissingSlotEnabled,
+  setHasEntry,
   setMemberDiagCollector,
+  setSizeAbs,
   shapeOfTerm,
   shapeOnlyFn,
   shapeToString,
@@ -256,6 +312,8 @@ import {
   superNameOf,
   tagAbsOrigin,
   tagDerivationRoot,
+  takeLoopExits,
+  takeThrowExits,
   templateMatchesValue,
   templatePartsOf,
   termDepth,
@@ -280,7 +338,7 @@ import {
   withExecPhi,
   withVar,
   wrapPromise
-} from "./chunk-P3G2TODS.js";
+} from "./chunk-6REHMIAE.js";
 
 // src/environment.ts
 function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
@@ -409,6 +467,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) {
@@ -425,8 +486,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);
@@ -449,13 +512,39 @@ function formatShape(a) {
     case "tuple":
       return `[${s.elements.map(formatShape).join(", ")}]`;
     case "fn": {
-      if (s.paramTypes && s.paramTypes.length > 0) {
-        const ps = s.paramTypes.map((p) => formatShapeSlot(p));
-        const ret2 = s.returnType !== void 0 ? formatShapeSlot(s.returnType) : "?";
-        return `(${ps.join(", ")}) => ${ret2}`;
-      }
       const ret = s.returnType !== void 0 ? formatShapeSlot(s.returnType) : "?";
-      return `(${s.params.join(", ")}) => ${ret}`;
+      const labels = s.params ?? [];
+      const paramTypes = s.paramTypes;
+      const hasMarkers = labels.some(
+        (p) => p.startsWith("...") || p.endsWith("?")
+      );
+      const renderLabeled = () => {
+        const ps = [];
+        const n = paramTypes ? Math.max(paramTypes.length, labels.length) : labels.length;
+        for (let i = 0; i < n; i++) {
+          const label = labels[i];
+          const type = paramTypes?.[i];
+          const typeText = type !== void 0 ? formatShapeSlot(type) : void 0;
+          if (label?.startsWith("...")) {
+            ps.push(typeText ? `...${label.slice(3)}: ${typeText}` : label);
+          } else if (label?.endsWith("?")) {
+            ps.push(typeText ? `${label.slice(0, -1)}?: ${typeText}` : label);
+          } else if (typeText !== void 0) {
+            ps.push(typeText);
+          } else if (label) {
+            ps.push(label);
+          }
+        }
+        return ps;
+      };
+      if (hasMarkers) {
+        return `(${renderLabeled().join(", ")}) => ${ret}`;
+      }
+      if (paramTypes && paramTypes.length > 0) {
+        const ps = paramTypes.map((p) => formatShapeSlot(p));
+        return `(${ps.join(", ")}) => ${ret}`;
+      }
+      return `(${labels.join(", ")}) => ${ret}`;
     }
     case "brand":
       return `${s.name}`;
@@ -573,6 +662,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");
@@ -1039,12 +1131,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
     });
   };
@@ -1068,7 +1161,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");
@@ -1092,15 +1185,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;
     }
@@ -1120,20 +1238,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",
@@ -1207,7 +1326,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) {
@@ -1319,9 +1438,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",
@@ -1573,28 +1695,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);
+        }
       }
     }
   }
@@ -1651,6 +1879,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 };
@@ -1660,6 +1900,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 });
@@ -1671,7 +1912,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({
@@ -1689,11 +1943,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) {
@@ -1990,6 +2249,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();
@@ -2176,11 +2456,167 @@ function canSkipLiteralCallScan(source, file) {
   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
 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,
@@ -2200,6 +2636,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 })
@@ -2208,7 +2645,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);
@@ -2224,6 +2661,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 }));
@@ -2240,6 +2678,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);
@@ -2260,6 +2699,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);
@@ -2324,14 +2764,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);
@@ -2529,6 +2969,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);
@@ -2645,6 +3090,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) {
@@ -2654,30 +3100,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);
@@ -2696,7 +3165,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) => ({
@@ -2812,6 +3281,7 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
       entryShapes,
       fnRels
     ),
+    ...formals.length > 0 ? { formals } : {},
     ...entryReqs ? { entryReqs } : {},
     ...fnRels ? { fnRels } : {},
     ...entryShapes ? { entryShapes } : {},
@@ -3506,6 +3976,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) {
@@ -3522,121 +4012,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 (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 === "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 (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) {
@@ -4009,14 +4426,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;
@@ -4050,15 +4490,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;
@@ -4135,14 +4596,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
@@ -4157,14 +4617,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
@@ -4346,14 +4805,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);
       }
@@ -4468,11 +4948,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,
@@ -4484,7 +4964,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) => {
@@ -4494,7 +4974,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,
@@ -4520,7 +5000,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({
@@ -4536,7 +5016,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,
@@ -4580,19 +5060,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",
@@ -4613,65 +5089,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;
@@ -4768,6 +5185,14 @@ function extractLiteralEvidence(rec, idx) {
 }
 
 // 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();
@@ -4791,7 +5216,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);
 }
@@ -4838,7 +5263,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) {
@@ -5011,6 +5437,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({
@@ -5340,10 +5786,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,
@@ -5351,15 +5806,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;
@@ -5658,8 +6138,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 {
@@ -5668,6 +6152,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) {
@@ -5688,7 +6178,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 } : {}
         });
       }
     }
@@ -5700,11 +6191,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 } : {}
       });
     }
   }
@@ -5882,6 +6376,8 @@ function termIsValue(t, a) {
 export {
   $add,
   $arr,
+  $arrMutContainer,
+  $arrRest,
   $async,
   $asyncReturn,
   $await,
@@ -5893,6 +6389,7 @@ export {
   $div,
   $elems,
   $eq,
+  $eqLoose,
   $fnVal,
   $for,
   $forIter,
@@ -5906,22 +6403,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,
@@ -5932,6 +6436,10 @@ export {
   $thisGet,
   $thisSet,
   $throw,
+  $tryCurrentMark,
+  $tryMark,
+  $tryPopMark,
+  $tryTakeSince,
   $typeof,
   $while,
   $whileSeq,
@@ -5939,6 +6447,7 @@ export {
   DEFAULT_MAX_LOOP_ITERS,
   MAX_CALL_DEPTH,
   MAX_TOTAL_CALLS,
+  NudoReturn,
   NudoSidecarError,
   NudoThrow,
   SELF,
@@ -5955,6 +6464,7 @@ export {
   analyzeFn,
   analyzeFnFull,
   and,
+  any,
   anyVar,
   app,
   applyAbsFn,
@@ -5964,6 +6474,7 @@ export {
   asAbsVal,
   attachFnImpl,
   awaitAbs,
+  beginCollectionFork,
   beginDerivationSession,
   betaOf,
   bindImports,
@@ -5972,6 +6483,7 @@ export {
   boolean,
   buildArgsFromAssume,
   callAbsMethod,
+  callAtFunctionBoundary,
   callFunction,
   callFunctionFull,
   callTranspiledExport,
@@ -5983,14 +6495,19 @@ export {
   checkSource,
   classFromMethods,
   clearBClasses,
+  clearCollectionTables,
   cmp,
   coerceAsyncReturn,
   collectAbsExports,
+  collectAbsFreeVars,
   collectAbsInlays,
   collectAbsNodeTypes,
+  collectionElementJoin,
+  collectionExactLen,
   concatString,
   confJoin,
   constraintToEntryAbs,
+  contractParamNameSet,
   createEnvironment,
   createHofCollectCtx,
   createTemplateAbs,
@@ -6009,8 +6526,10 @@ export {
   effectiveInterface,
   emptyEnv,
   emptyPhi,
+  endCollectionFork,
   endDerivationSession,
   eq,
+  errorBrandAbs,
   evalArrayStatic,
   evalBuiltinInstanceMethod,
   evalBuiltinNew,
@@ -6047,11 +6566,15 @@ export {
   fnConstraintToEntryReqs,
   fnFingerprints,
   fnOf,
+  formalParamDisplayNames,
+  formalParamsFromNodes,
   formatAbs,
   formatAbsMultiline,
   formatCheckReport,
   formatConstraint,
   formatDiagnostics,
+  formatEffectiveInterfaceDisplay,
+  formatInterfaceTierLine,
   formatShape,
   formatShapeSlot,
   formatTemplateNameViews,
@@ -6084,17 +6607,25 @@ export {
   instantiateConstraint,
   instantiateReturn,
   interfaceDiagCount,
+  interfaceSourceOf,
+  interfaceTierOf,
+  isArrMutator,
   isDefinitelyFalse,
   isDefinitelyTrue,
+  isErrorCtorName,
+  isEvalMissingSlotEnabled,
   isExactLit,
   isIntFlag,
+  isMapAbs,
   isNodeModulesPath,
   isNudoConstraint,
+  isNudoReturn,
   isNudoThrow,
   isNullishLitAbs,
   isNumPrim,
   isObj,
   isRelFn,
+  isSetAbs,
   isStrPrim,
   isTemplateLike,
   joinAbs,
@@ -6116,16 +6647,29 @@ 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,
+  mergeCollectionArms,
   mock,
   mod,
   mul,
@@ -6136,9 +6680,11 @@ export {
   normPath,
   not,
   notAbs,
+  noteCollectionWrite,
   noteDerivationAdd,
   noteDerivationJoin,
   noteMemberDispatchMiss,
+  noteObjSlotMissing,
   notePrimMemberMissing,
   noteUnknownMemberMissing,
   num,
@@ -6155,6 +6701,7 @@ export {
   partial,
   phiAnd,
   pick,
+  popCollectionArm,
   popPhi,
   predEquals,
   predToString,
@@ -6164,7 +6711,10 @@ export {
   projectFlatMapResult,
   promoteParamShape,
   ptypeof,
+  pushCollectionArm,
+  pushLoopExit,
   pushPhi,
+  pushThrowExit,
   recordMemberDiag,
   refineAbsForRelTrue,
   refineDiagCount,
@@ -6172,6 +6722,7 @@ export {
   registerBClass,
   relationFingerprint,
   relationFn,
+  requiredFnArity,
   resetAbsCallBudget,
   resetCheckSourceMemo,
   resetFnFpCache,
@@ -6183,18 +6734,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,
+  setSizeAbs,
   shape,
   shapeOfTerm,
   shapeOnlyFn,
@@ -6222,8 +6782,10 @@ export {
   tagDerivationRoot,
   takeInterfaceDiags,
   takeInterfaceDiagsSince,
+  takeLoopExits,
   takeRefineDiags,
   takeRefineDiagsSince,
+  takeThrowExits,
   templateMatchesValue,
   templatePartsOf,
   termDepth,