@nudojs/core 1.15.2 → 1.16.0

package/dist/index.js

@@ -2,10 +2,16 @@ import "./chunk-US532PZA.js";
 import {
   INTERFACE_SOURCE_ABBR,
   NudoSidecarError,
+  absWithStableTermIds,
   actionsForIssue,
   buildArgsFromAssume,
   canSkipLiteralCallScan,
+  checkArg,
+  checkCall,
   collectAbsFreeVars,
+  contractSegmentLocs,
+  ctorParamCountOf,
+  deferredExecutionSpans,
   effectiveInterface,
   evictGeneralizeMemoForPaths,
   execNudoModule,
@@ -27,6 +33,7 @@ import {
   fnTopLevelLocalNames,
   formatCheckReport,
   formatConstraint,
+  formatDiagnostics,
   formatEffectiveInterfaceDisplay,
   formatGithubAnnotations,
   formatGitlabCodeQuality,
@@ -35,20 +42,24 @@ import {
   generalizeFromAst,
   generatedExportNames,
   getGeneralizeMemoSize,
+  guardLoadModule,
   hashSource,
   interfaceDiagCount,
   interfaceSourceOf,
   interfaceTierOf,
   isNodeModulesPath,
+  listClassEntryNames,
   listFnDirectiveScopes,
   listFunctionNames,
   listTopFunctions,
   loadModuleDepsFingerprint,
   localNamedExports,
+  nodeSpan,
   normPath,
   parseEnvPayload,
   parseMockModulePayload,
   parseNudoImportPayload,
+  reachableTopBindings,
   refineDiagCount,
   refineToIndexedFull,
   resetGeneralizeMemo,
@@ -56,6 +67,7 @@ import {
   resetNudoModuleExecCache,
   resetSidecarLoadFailureCache,
   resolveDepPath,
+  resolveExportSlotCall,
   scanBudgetDecl,
   scanCaseArgSpans,
   scanCaseTags,
@@ -66,6 +78,7 @@ import {
   serializeCheckJsonMulti,
   setInterfaceDiagCollector,
   setRefineDiagCollector,
+  sidecarAutoBindAllowed,
   sidecarClosureFingerprint,
   sidecarPathOf,
   stableAnalyzeKeySource,
@@ -74,7 +87,7 @@ import {
   takeInterfaceDiagsSince,
   takeRefineDiags,
   takeRefineDiagsSince
-} from "./chunk-NXZSRLCT.js";
+} from "./chunk-POGFCYV2.js";
 import {
   $add,
   $arguments,
@@ -193,6 +206,7 @@ import {
   DIAG,
   FORK_TRUNCATION_LABEL,
   HOST_EFFECT_LABEL_PREFIX,
+  LAZY_TEMPLATE_DEPTH,
   LOOP_TRUNCATION_LABEL,
   MATH_FOLD_ERROR_LABEL,
   MAX_EVAL_CALL_DEPTH,
@@ -213,6 +227,7 @@ import {
   absOnly,
   absShapeKey,
   absToString,
+  accessorReadDomain,
   add,
   alphaOf,
   and,
@@ -227,6 +242,7 @@ import {
   asAbs,
   asAbsVal,
   assignSourceSlots,
+  assumeConsumed,
   assumeFinite,
   attachContractFaces,
   attachFnImpl,
@@ -362,6 +378,7 @@ import {
   isSetAbs,
   isStrPrim,
   isSymbolAbs,
+  isThrowsIgnored,
   joinAbs,
   joinFunctions,
   joinObjects,
@@ -415,6 +432,7 @@ import {
   never,
   not,
   notAbs,
+  noteAssumeConsumed,
   noteCollectionWrite,
   noteEvalCallRecord,
   noteEvalFallback,
@@ -460,6 +478,7 @@ import {
   relationFn,
   requiredFnArity,
   resetAbsCallBudget,
+  resetAssumeConsumed,
   resetEvalCallBudget,
   resetParseSourceCache,
   runTranspiled,
@@ -526,6 +545,7 @@ import {
   tryPromoteHofCallback,
   tryPromoteReceiverAsArr,
   tryRunTranspiled,
+  tryRunTranspiledDetailed,
   typeofAbs,
   undefAbs,
   union,
@@ -536,7 +556,7 @@ import {
   withExecPhi,
   withInvariantSpecs,
   withVar
-} from "./chunk-WKIRPUHZ.js";
+} from "./chunk-OM6SAY2M.js";
 
 // src/environment.ts
 function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
@@ -652,123 +672,6 @@ function describePhi() {
   return p.op === "true" ? "\u22A4" : "(phi)";
 }
 
-// src/algebra/diagnostics.ts
-function checkArg(arg, expect, phi = pTrue) {
-  if (!expect || expect.op === "true") return void 0;
-  if (arg.shape.k === "unknown" && !arg.term) {
-    return {
-      severity: "warning",
-      code: DIAG.argOpaque,
-      message: `argument type is unknown; cannot verify constraint ${predToString(expect)}`,
-      suggestion: "add a call site or @nudo:case, or provide preconditions via --assume"
-    };
-  }
-  const combined = arg.pred && arg.pred.op !== "true" ? phi.op === "true" ? arg.pred : { op: "and", args: [phi, arg.pred] } : phi;
-  if (implies(combined, expect)) return void 0;
-  const lvR = litValue(arg);
-  if (lvR.ok && (expect.op === "gt" || expect.op === "ge" || expect.op === "lt" || expect.op === "le")) {
-    const ok = decideLitCmp(lvR.value, expect);
-    if (ok === true) return void 0;
-    if (ok === false) {
-      return {
-        severity: "error",
-        code: DIAG.constraintViolated,
-        message: `argument ${JSON.stringify(lvR.value)} does not satisfy ${predToString(expect)}`,
-        suggestion: `use a value satisfying the constraint, or relax the function precondition`
-      };
-    }
-  }
-  return {
-    severity: "warning",
-    code: DIAG.constraintUnproven,
-    message: `cannot prove the argument satisfies ${predToString(expect)}`,
-    suggestion: `not enough information; use --assume or add a case`
-  };
-}
-function decideLitCmp(lv, p) {
-  if (typeof lv !== "number" || p.b.op !== "lit" || typeof p.b.value !== "number") {
-    return void 0;
-  }
-  const n = p.b.value;
-  switch (p.op) {
-    case "gt":
-      return lv > n;
-    case "ge":
-      return lv >= n;
-    case "lt":
-      return lv < n;
-    case "le":
-      return lv <= n;
-    default:
-      return void 0;
-  }
-}
-function checkCall(source, fnName, args, phi = pTrue) {
-  const diags = [];
-  const g = generalizeFromAst(fnName, source);
-  if (!g) {
-    diags.push({
-      severity: "error",
-      code: DIAG.fnNotFound,
-      message: `function ${fnName} not found`
-    });
-    return diags;
-  }
-  if (args.length !== g.params.length) {
-    diags.push({
-      severity: "error",
-      code: DIAG.argCount,
-      message: `${fnName} expects ${g.params.length} argument(s), got ${args.length}`,
-      fn: fnName
-    });
-    return diags;
-  }
-  const required = extractParamRequirements(g);
-  args.forEach((arg, i) => {
-    const req = required.get(i);
-    const d = checkArg(arg, req, phi);
-    if (d) diags.push({ ...d, fn: fnName, argIndex: i });
-  });
-  if (g.symbolic.conf === "partial" || g.symbolic.conf === "opaque") {
-    diags.push({
-      severity: "info",
-      code: DIAG.partialResult,
-      message: `${fnName}(...) result confidence ${g.symbolic.conf}`,
-      suggestion: "add a call site or constraint to improve precision",
-      fn: fnName
-    });
-  }
-  return diags;
-}
-function extractParamRequirements(g) {
-  const map = /* @__PURE__ */ new Map();
-  const pred = g.symbolic.pred;
-  if (!pred || pred.op === "true") return map;
-  const paramIndex = /* @__PURE__ */ new Map();
-  g.typeParams.forEach((t, i) => paramIndex.set(t.id, i));
-  const consider = (p) => {
-    if (p.op === "and") {
-      p.args.forEach(consider);
-      return;
-    }
-    if ((p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") && p.a.op === "var" && paramIndex.has(p.a.id) && p.b.op === "lit") {
-      map.set(paramIndex.get(p.a.id), p);
-    }
-  };
-  consider(pred);
-  return map;
-}
-function formatDiagnostics(diags) {
-  if (diags.length === 0) return "No issues found.";
-  return diags.map((d) => {
-    const loc = d.fn ? `${d.fn}${d.argIndex !== void 0 ? `[${d.argIndex}]` : ""}: ` : "";
-    let s = `[${d.severity}] ${loc}${d.message} (${d.code})`;
-    if (d.suggestion) s += `
-    \u2192 ${d.suggestion}`;
-    return s;
-  }).join("\n");
-}
-
 // src/algebra/check.ts
 import { isBuiltin } from "module";
 
@@ -794,12 +697,43 @@ function isValueSetUnknown(ret) {
   if (ret.shape.k === "any") return true;
   return false;
 }
-function isBoundedEvidenceMissing(ret, constraint) {
+function isBoundedEvidenceMissing(ret, constraint, phi) {
   if (constraint.preds.length === 0 && !constraint.members) return false;
   if (ret.term?.op === "lit") return false;
   if (ret.pred && ret.pred.op !== "true") return false;
+  if (phiSuppliesConstraint(phi, constraint, ret)) return false;
   return true;
 }
+function phiSuppliesConstraint(phi, constraint, ret) {
+  if (!phi || phi.op === "true") return false;
+  const item = retAnchorTerm(ret);
+  if (!hasSameItemBoundEvidence(phi, item)) return false;
+  return implies(phi, instantiateOnTerm(constraint, item));
+}
+function hasSameItemBoundEvidence(p, item) {
+  if (!p) return false;
+  switch (p.op) {
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+      return sameItemTerm(item, p.a);
+    case "and":
+    case "or":
+      return p.args.some((a) => hasSameItemBoundEvidence(a, item));
+    case "not":
+      return hasSameItemBoundEvidence(p.arg, item);
+    default:
+      return false;
+  }
+}
+function sameItemTerm(item, left) {
+  if (termEquals(item, left)) return true;
+  if (left.op === "app" && left.fn === "length" && left.args.length === 1) {
+    return termEquals(item, left.args[0]);
+  }
+  return false;
+}
 function flattenSumArms(ret) {
   if (ret.shape.k !== "sum") return [ret];
   const out = [];
@@ -956,7 +890,11 @@ function assertImpliesSingle(arm, constraint, opts, phi) {
     }
     return r.status === "unprovable" ? unprovable(`array element: ${r.reason}`) : proved();
   }
-  if (constraint.fn) return proved();
+  if (constraint.fn) {
+    return unprovable(
+      "fn-shaped return contract cannot be enforced (declare the returned value as the fn's returns constraint)"
+    );
+  }
   return assertScalar(arm, constraint, phi);
 }
 function isAnyConstraint(c) {
@@ -981,7 +919,7 @@ function assertShapeFields(ret, constraint, opts) {
       }
       continue;
     }
-    const r = assertImplies(slot.value, field.constraint, opts);
+    const r = assertImplies(accessorReadDomain(ret, key) ?? slot.value, field.constraint, opts);
     if (r.status === "disproved") {
       return disproved(`field ${key}: ${r.reason}`);
     }
@@ -1022,10 +960,14 @@ function assertScalar(ret, constraint, phi) {
   }
   if (constraintPred.op !== "true") {
     if (implies(retPred, constraintPred)) return proved();
+    if (phi.op !== "true" && ret.pred && ret.pred.op !== "true" && implies(ret.pred, constraintPred)) {
+      return proved();
+    }
     if (ret.pred && ret.pred.op !== "true" && numericBoundsImplyLocal(ret.pred, constraintPred)) {
       return proved();
     }
-    if (isBoundedEvidenceMissing(ret, constraint)) {
+    if (phiSuppliesConstraint(phi, constraint, ret)) return proved();
+    if (isBoundedEvidenceMissing(ret, constraint, phi)) {
       return unprovable(
         `cannot prove return satisfies ${formatConstraint(constraint)} (no bound evidence on the return value)`
       );
@@ -1044,7 +986,7 @@ function assertScalar(ret, constraint, phi) {
     }
   }
   if (constraintPred.op !== "true" || constraint.preds.length > 0) {
-    if (isBoundedEvidenceMissing(ret, constraint)) {
+    if (isBoundedEvidenceMissing(ret, constraint, phi)) {
       return unprovable(
         `cannot prove return satisfies ${formatConstraint(constraint)} (no bound evidence on the return value)`
       );
@@ -1127,6 +1069,104 @@ function isLengthSelfTerm(t) {
   return t.op === "app" && t.fn === "length" && t.args.length === 1 && t.args[0].op === "var" && t.args[0].id === SELF;
 }
 
+// src/algebra/check-return.ts
+function checkReturnConstraint(fnName, cName, constraint, ret, audit = {}) {
+  const {
+    loc,
+    source = "directive",
+    assumeDisplay,
+    invariantDisplay,
+    consumedAssume,
+    phi,
+    phiPremises
+  } = audit;
+  const proof = assertImplies(ret, constraint, phi ? { phi } : void 0);
+  const phiUsedIdx = /* @__PURE__ */ new Set();
+  if (phi && proof.status === "proved" && phiPremises && phiPremises.length > 0) {
+    const withoutPhi = assertImplies(ret, constraint);
+    if (withoutPhi.status !== "proved") {
+      const solo = phiPremises.filter(
+        (p) => phiSuppliesConstraint(p, constraint, ret)
+      );
+      const used = solo.length > 0 ? solo : [...phiPremises];
+      for (const p of used) noteAssumeConsumed(p);
+      phiPremises.forEach((p, i) => {
+        if (used.includes(p)) phiUsedIdx.add(i);
+      });
+    }
+  }
+  const where = () => {
+    if (loc?.line === void 0) return {};
+    return loc.column === void 0 ? { line: loc.line } : { line: loc.line, column: loc.column };
+  };
+  const origin = source === "sidecar" ? `sidecar fn() return slot (${cName})` : `@nudo:contract return ${cName}`;
+  if (proof.status === "proved") {
+    const ledgerUsedIdx = /* @__PURE__ */ new Set();
+    if (assumeDisplay && phiPremises) {
+      const consumed = assumeConsumed();
+      for (let i = 0; i < assumeDisplay.length; i++) {
+        const premise = phiPremises[i];
+        if (premise !== void 0 && consumed.includes(premise)) ledgerUsedIdx.add(i);
+      }
+    }
+    const relied = [];
+    const usedAssume = (assumeDisplay ?? []).filter(
+      (d, i) => consumedAssume?.has(d) === true || ledgerUsedIdx.has(i) || phiUsedIdx.has(i)
+    );
+    if (usedAssume.length > 0) {
+      relied.push({
+        severity: "info",
+        code: DIAG.assumeRelied,
+        message: `${fnName}: return contract proved via @nudo:assume ${usedAssume.join("; ")}`,
+        actual: `proof relies on user lemma${usedAssume.length > 1 ? "s" : ""}`,
+        expected: "engine verifies the obligation, not the lemma itself",
+        suggestion: "@nudo:assume is a user-supplied axiom \u2014 falsify it with concrete @nudo:case runs (nudo test)",
+        fn: fnName,
+        ...where()
+      });
+    }
+    if (invariantDisplay && invariantDisplay.length > 0) {
+      relied.push({
+        severity: "info",
+        code: DIAG.invariantRelied,
+        message: `${fnName}: return contract proved via @nudo:invariant ${invariantDisplay.join("; ")}`,
+        actual: `proof relies on user invariant${invariantDisplay.length > 1 ? "s" : ""}`,
+        expected: "engine verifies the obligation, not the loop invariant itself",
+        suggestion: "@nudo:invariant is a user-supplied axiom \u2014 falsify it with concrete @nudo:case runs (nudo test)",
+        fn: fnName,
+        ...where()
+      });
+    }
+    return relied;
+  }
+  const push = (severity, actual, expected, suggestion) => [
+    {
+      severity,
+      code: severity === "error" ? DIAG.constraintViolated : DIAG.unprovenReturn,
+      message: `${fnName}: return value \u22AD ${origin}`,
+      actual,
+      expected,
+      suggestion,
+      fn: fnName,
+      ...where()
+    }
+  ];
+  if (proof.status === "disproved") {
+    return push(
+      "error",
+      formatAbs(ret),
+      proof.reason,
+      proof.reason.includes("nullish") ? `use nullable(${formatConstraint(constraint)}) or union(..., lit(null)) to allow nullish returns` : `return a value satisfying ${formatConstraint(constraint)}`
+    );
+  }
+  return push(
+    "warning",
+    formatAbs(ret),
+    formatConstraint(constraint),
+    `${proof.reason}; add a precondition, narrow the return expression, or relax the return contract`
+  );
+}
+
 // src/algebra/projection.ts
 var PROJECTABLE_CONF = /* @__PURE__ */ new Set(["exact", "path"]);
 var ARR_FALLBACK_CONF = /* @__PURE__ */ new Set([
@@ -1134,6 +1174,9 @@ var ARR_FALLBACK_CONF = /* @__PURE__ */ new Set([
   "path",
   "widened"
 ]);
+function isHiddenInternalSlot(k, slot) {
+  return slot.internal === true && canonicalArrayIndex(k) === void 0;
+}
 function absToConstraint(a, budget = new ProjectionBudget()) {
   if (!PROJECTABLE_CONF.has(a.conf)) return void 0;
   const stop = budget.enter(a);
@@ -1162,7 +1205,7 @@ function absToConstraintInner(a, budget) {
     case "any":
       return a.pred?.op === "or" ? projectOrLiterals(a) : void 0;
     case "obj":
-      return projectObj(s.slots, s.index, s.open, budget);
+      return projectObj(a, s, budget);
     case "arr":
       return projectArr(s.element, budget);
     case "sum":
@@ -1347,11 +1390,12 @@ function projectOrLiterals(a) {
   }
   return lits.length > 0 ? union(...lits) : void 0;
 }
-function projectObj(slots, index, open, budget) {
-  if (index || open) return void 0;
-  const fields = {};
-  for (const [k, slot] of Object.entries(slots)) {
-    const fc = absToConstraint(slot.value, budget);
+function projectObj(a, s, budget) {
+  if (s.index || s.open) return void 0;
+  const fields = /* @__PURE__ */ Object.create(null);
+  for (const [k, slot] of Object.entries(s.slots)) {
+    if (isHiddenInternalSlot(k, slot)) continue;
+    const fc = absToConstraint(accessorReadDomain(a, k) ?? slot.value, budget);
     if (!fc) return void 0;
     fields[k] = { constraint: fc, ...slot.optional ? { optional: true } : {} };
   }
@@ -1590,11 +1634,21 @@ function isDefaultExportName(source, fnName) {
   );
   return re.test(source);
 }
+function formatEntryParamShape(t) {
+  if (t.shape.k === "unknown") {
+    const term = t.term;
+    if (term?.op === "lit" && (term.value === null || term.value === void 0)) {
+      return formatShape(t);
+    }
+    return "unknown";
+  }
+  return formatShape(t, { showLits: true });
+}
 function formatEntrySigLine(name, g, throws) {
   const names = g.formals && g.formals.length > 0 ? formalParamSignatureNames(g.formals) : g.params;
   const ps = names.map((p, i) => {
     const t = g.typeParams[i]?.value;
-    const shown = !t ? "any" : t.shape.k === "unknown" ? "unknown" : formatShape(t);
+    const shown = !t ? "any" : formatEntryParamShape(t);
     return `${p}: ${shown}`;
   }).join(", ");
   return `${name}(${ps}) => ${formatShape(g.symbolic)}    throws ${throws}`;
@@ -1633,14 +1687,25 @@ function findFnLoc(file, name) {
   }
   return {};
 }
+function formatSigDetail(absVal, name) {
+  return formatAbsMultiline(absWithStableTermIds(absVal), name);
+}
 function formatSigCached(absVal, name) {
-  const hit = sigFormatCache.get(absVal);
+  let byName = sigFormatCache.get(absVal);
+  if (!byName) {
+    byName = /* @__PURE__ */ new Map();
+    sigFormatCache.set(absVal, byName);
+  }
+  const hit = byName.get(name);
   if (hit) return hit;
   const out = {
-    display: formatAbs(absVal),
-    detail: formatAbsMultiline(absVal, name)
+    // **人类面口径**（`formatShape`）：与 `formatCheckReport` 的签名行**逐字
+    // 同源**（Bug 413：机器面此前用 `formatAbs` ⇒ 把 term / pred 段渲进
+    // 对外载荷，其中混着引擎内部计数器 id `len#N` ⇒ 载荷随参数列表位置漂移）。
+    display: formatShape(absVal),
+    detail: formatSigDetail(absVal, name)
   };
-  sigFormatCache.set(absVal, out);
+  byName.set(name, out);
   return out;
 }
 
@@ -1667,12 +1732,6 @@ function loadModuleId(fn2) {
   }
   return id;
 }
-function checkDepsFingerprint(source, opts) {
-  if (!opts.loadModule || !opts.fromFile) {
-    return { fp: "-", paths: [], contents: [], truncated: false, readError: false };
-  }
-  return loadModuleDepsFingerprint(source, opts.loadModule, opts.fromFile);
-}
 function unindexCheckKey(key) {
   const deps = checkKeyDeps.get(key);
   if (!deps) return;
@@ -1741,13 +1800,23 @@ function checkMemoKey(filePath, source, identityOpts, deps, sidecarFp) {
     runTranspiledOptionsMemoKey(identityOpts.inject),
     // skips 必须进键：同 source 不同 skip 表（host 解析差异 / 测试注入）
     // 不得回放另一档报告。
-    skipsKey(identityOpts.skips)
+    skipsKey(identityOpts.skips),
+    // Bug 366：`from`（--from 的跨文件调用点证据）必须进键——同 source 不同
+    // 证据不得互为陈旧命中：无证据那档会把有证据的 drift 吞掉，有证据那档
+    // 会把 drift 回放进无证据的检查（假阳）。
+    fromKey(identityOpts.from)
   ].join("|");
 }
 function skipsKey(skips) {
   if (!skips || skips.size === 0) return "-";
   return [...skips.entries()].map(([name, abs2]) => `${name}:${abs2 ? formatAbs(abs2) : "-"}`).sort().join(",");
 }
+function fromKey(from) {
+  if (!from || from.length === 0) return "-";
+  return from.map(
+    (r) => `${r.fnName}:${r.args.map((a) => formatAbs(a)).join(",")}:${formatAbs(r.result)}`
+  ).sort().join(";");
+}
 function checkMemoGet(key) {
   if (!checkReportMemo.has(key)) return null;
   const v2 = checkReportMemo.get(key);
@@ -1785,8 +1854,17 @@ function collectEntryMayThrows(source, fnName, g, file, phi, opts = {}) {
   return runWithMayThrowSession(() => {
     setMayThrowCollector((e) => effects.push(e));
     try {
-      const full = evalThrowsOf(source, fnName, entryArgs, opts, phi);
-      if (!full) return effects;
+      const outcome = evalThrowsOutcome(source, fnName, entryArgs, opts, phi, file);
+      if (outcome.kind === "unanalyzable") {
+        if (!unsupportedFallsInside(file, fnName, outcome.reason, outcome.loc)) return effects;
+        effects.push({
+          kind: "Error",
+          cause: `entry not analyzed (${outcome.reason}) \u21D2 may-throw undeterminable`
+        });
+        return effects;
+      }
+      if (outcome.kind !== "analyzed") return effects;
+      const full = outcome.result;
       if (full.throws && full.throws.shape.k !== "never") {
         for (const tName of throwAbsToKinds(full.throws)) {
           if (!effects.some((e) => e.kind === tName && e.cause.startsWith("throw"))) {
@@ -1828,7 +1906,13 @@ function invokeAsThrows(fn2, phi = pTrue) {
     throw e;
   }
 }
-function evalThrowsOf(source, fnName, args, opts = {}, phi = pTrue) {
+function declaredThrowsForEntry(source, fnName) {
+  const own = extractDeclaredThrows(source, fnName);
+  if (own !== void 0) return own;
+  if (fnName.includes(".")) return void 0;
+  return extractDeclaredThrows(source, `${fnName}.constructor`);
+}
+function evalThrowsOutcome(source, fnName, args, opts = {}, phi = pTrue, file) {
   const runKey = `${source}|${runTranspiledOptionsMemoKey(opts.inject)}|${runTranspiledOptionsMemoKey(opts.modules ? { modules: opts.modules } : void 0)}`;
   if (evalRunMemo.size >= MAX_CHECK_MEMO) {
     const oldest = evalRunMemo.keys().next().value;
@@ -1836,9 +1920,16 @@ function evalThrowsOf(source, fnName, args, opts = {}, phi = pTrue) {
   }
   let exports = evalRunMemo.get(runKey);
   if (exports === void 0) {
-    const run = tryRunTranspiled(source, evalAnalyzeOpts(opts));
-    if (run === void 0) return void 0;
-    exports = run;
+    const attempt = tryRunTranspiledDetailed(source, evalAnalyzeOpts(opts));
+    if (attempt.run === void 0) {
+      const reason = attempt.fallback?.reason ?? "transpile failed";
+      if (reason.startsWith("unsupported:")) {
+        const loc = attempt.fallback?.loc;
+        return loc ? { kind: "unanalyzable", reason, loc } : { kind: "unanalyzable", reason };
+      }
+      return { kind: "absent" };
+    }
+    exports = attempt.run;
     evalRunMemo.set(runKey, exports);
   }
   const isAbsVal2 = (v2) => !!v2 && typeof v2 === "object" && "shape" in v2 && "conf" in v2;
@@ -1850,29 +1941,336 @@ function evalThrowsOf(source, fnName, args, opts = {}, phi = pTrue) {
     }
   };
   try {
-    if (Object.hasOwn(exports, fnName)) return call(fnName, args);
+    if (!fnName.includes(".")) {
+      const clsAbs = classAbsOf(exports, file, fnName);
+      if (isAbsVal2(clsAbs) && isClassValueAbs(clsAbs)) {
+        return {
+          kind: "analyzed",
+          result: classEntryThrows(clsAbs, file, fnName, phi)
+        };
+      }
+    }
+    if (Object.hasOwn(exports, fnName)) {
+      const r = call(fnName, args);
+      return r ? { kind: "analyzed", result: r } : { kind: "absent" };
+    }
     if (fnName.includes(".")) {
       const [clsName, methodName] = fnName.split(".", 2);
-      const clsAbs = exports[clsName ?? ""];
+      const clsAbs = classAbsOf(exports, file, clsName ?? "");
       if (isAbsVal2(clsAbs)) {
-        return invokeAsThrows(() => $staticInvoke(clsAbs, methodName ?? "", args), phi);
+        if (classMethodIsStatic(file, clsName ?? "", methodName ?? "") === false) {
+          return {
+            kind: "analyzed",
+            result: invokeAsThrows(() => {
+              const inst = instanceForMethodBridge(
+                clsAbs,
+                clsName ?? "",
+                ctorAnyArgs(file, clsName ?? "")
+              );
+              return $invoke(inst, methodName ?? "", args);
+            }, phi)
+          };
+        }
+        return {
+          kind: "analyzed",
+          result: invokeAsThrows(() => $staticInvoke(clsAbs, methodName ?? "", args), phi)
+        };
       }
-      return void 0;
+      return { kind: "absent" };
     }
     if ("default" in exports) {
       const d = exports["default"];
-      if (typeof d === "function") return call("default", args);
+      if (typeof d === "function") {
+        const r = call("default", args);
+        return r ? { kind: "analyzed", result: r } : { kind: "absent" };
+      }
       if (isAbsVal2(d)) {
-        if (d.shape.k === "fn") return call("default", args);
+        if (d.shape.k === "fn") {
+          const r = call("default", args);
+          return r ? { kind: "analyzed", result: r } : { kind: "absent" };
+        }
         if (d.shape.k === "obj") {
-          return invokeAsThrows(() => $invoke(d, fnName, args), phi);
+          return {
+            kind: "analyzed",
+            result: invokeAsThrows(() => $invoke(d, fnName, args), phi)
+          };
         }
       }
     }
+    return { kind: "absent" };
+  } catch {
+    return { kind: "absent" };
+  }
+}
+function classAbsOf(exports, file, clsName) {
+  const slot = file ? resolveExportSlotCall(file, clsName, exports) : void 0;
+  if (slot && slot.kind !== "cjs-member") return exports[slot.key];
+  return exports[clsName];
+}
+function isClassValueAbs(v2) {
+  return v2.shape.k === "brand" && v2.shape.ctor === true;
+}
+function classEntryThrows(clsAbs, file, clsName, phi) {
+  return invokeAsThrows(
+    () => runWithMayThrowSession(() => $new(clsAbs, ctorAnyArgs(file, clsName))),
+    phi
+  );
+}
+function classMethodIsStatic(file, clsName, methodName) {
+  if (!file) return void 0;
+  for (const stmt of file.program.body) {
+    const s = stmt;
+    let decl = stmt;
+    if (s.type === "ExportNamedDeclaration" || s.type === "ExportDefaultDeclaration") {
+      decl = s.declaration;
+    }
+    const c = decl;
+    if (!c || c.type !== "ClassDeclaration") continue;
+    if (c.id?.name !== clsName) continue;
+    for (const m of c.body?.body ?? []) {
+      const mem = m;
+      if (mem.kind === "constructor") continue;
+      if (classMemberName(mem) !== methodName) continue;
+      return mem.static === true;
+    }
     return void 0;
+  }
+  return void 0;
+}
+function ctorAnyArgs(file, clsName) {
+  const n = file ? ctorParamCountOf(file, clsName) : 0;
+  return Array.from({ length: n }, () => abs({ k: "any" }, void 0, pTrue, "path"));
+}
+function instanceForMethodBridge(clsAbs, clsName, ctorArgs) {
+  try {
+    return runWithMayThrowSession(() => $new(clsAbs, ctorArgs));
   } catch {
+    return bareInstanceOf(clsAbs, clsName);
+  }
+}
+function bareInstanceOf(clsAbs, clsName) {
+  const name = clsAbs.shape.k === "brand" && clsAbs.shape.name.length > 0 ? clsAbs.shape.name : clsName;
+  return abs(
+    {
+      k: "brand",
+      name,
+      shape: abs({ k: "unknown" }, void 0, void 0, "partial")
+    },
+    void 0,
+    void 0,
+    "path"
+  );
+}
+function classMemberName(m) {
+  const key = m.key;
+  if (!key) return void 0;
+  return key.name ?? (typeof key.value === "string" ? key.value : void 0);
+}
+function isExportsTarget(node) {
+  const n = node;
+  if (!n) return false;
+  if (n.type === "Identifier") return n.name === "exports";
+  if (n.type !== "MemberExpression") return false;
+  const obj2 = n.object;
+  const prop = n.property;
+  return obj2?.type === "Identifier" && obj2.name === "module" && prop?.name === "exports";
+}
+function cjsExportName(left) {
+  const l = left;
+  if (!l || l.type !== "MemberExpression" || l.computed === true) return void 0;
+  if (!isExportsTarget(l.object)) return void 0;
+  const prop = l.property;
+  return prop?.name;
+}
+function keyNameOf(node) {
+  const n = node;
+  if (!n) return void 0;
+  if (n.type === "Identifier" && typeof n.name === "string") return n.name;
+  if (n.type === "StringLiteral" && typeof n.value === "string") return n.value;
+  return void 0;
+}
+function entryValueNode(node) {
+  const n = node;
+  if (!n) return void 0;
+  return n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression" || n.type === "ClassDeclaration" || n.type === "ClassExpression" ? node : void 0;
+}
+function classMethodEntryNodes(cls, methodName) {
+  const members = cls.body?.body ?? [];
+  let method;
+  for (const m of members) {
+    if (m.kind === "constructor") continue;
+    if (classMemberName(m) !== methodName) continue;
+    method = m;
+    break;
+  }
+  if (!method) return void 0;
+  const isStatic = method.static === true;
+  const nodes = [method];
+  for (const m of members) {
+    if (m === method) continue;
+    if (m.kind === "constructor") {
+      if (!isStatic) nodes.push(m);
+      continue;
+    }
+    if (m.type === "StaticBlock") {
+      if (isStatic) nodes.push(m);
+      continue;
+    }
+    if (m.type === "ClassProperty" || m.type === "ClassPrivateProperty") {
+      if (m.static === true !== isStatic) continue;
+      nodes.push(m.value ?? m);
+    }
+  }
+  return nodes;
+}
+function cjsEntryNodes(file, expression, fnName, depth) {
+  const e = expression;
+  if (!e || e.type !== "AssignmentExpression" || e.operator !== "=") return void 0;
+  const right = e.right;
+  if (!right) return void 0;
+  const fromValue = (node) => {
+    const value = entryValueNode(node);
+    if (value) return [value];
+    const ident = node;
+    if (ident?.type === "Identifier" && ident.name) {
+      return entryNodesOf(file, ident.name, depth + 1);
+    }
     return void 0;
+  };
+  if (cjsExportName(e.left) === fnName) return fromValue(right);
+  if (!isExportsTarget(e.left)) return void 0;
+  if (right.type === "ObjectExpression") {
+    for (const p of right.properties ?? []) {
+      const prop = p;
+      if (keyNameOf(prop.key) !== fnName) continue;
+      if (prop.type === "ObjectMethod") return [prop];
+      return fromValue(prop.value);
+    }
+    return void 0;
+  }
+  if (right.type === "Identifier" && right.name === fnName) {
+    return entryNodesOf(file, fnName, depth + 1);
   }
+  return void 0;
+}
+function entryNodesOf(file, fnName, depth = 0) {
+  if (!file || depth > 3) return void 0;
+  for (const stmt of file.program.body) {
+    const s = stmt;
+    if (s.type === "ExpressionStatement") {
+      const hit = cjsEntryNodes(file, s.expression, fnName, depth);
+      if (hit) return hit;
+      continue;
+    }
+    let decl = stmt;
+    if (s.type === "ExportNamedDeclaration" || s.type === "ExportDefaultDeclaration") {
+      decl = s.declaration;
+    }
+    const d = decl;
+    if (!d || typeof d !== "object") continue;
+    if (fnName.includes(".")) {
+      const [clsName, methodName] = fnName.split(".", 2);
+      if (d.type !== "ClassDeclaration" || d.id?.name !== clsName) continue;
+      return classMethodEntryNodes(d, methodName ?? "");
+    }
+    if (d.type === "FunctionDeclaration" && d.id?.name === fnName) return [d];
+    if (fnName === "default" && s.type === "ExportDefaultDeclaration") {
+      const t = d.type;
+      if (t === "FunctionDeclaration" || t === "ArrowFunctionExpression" || t === "FunctionExpression" || t === "ClassDeclaration") {
+        return [d];
+      }
+    }
+    if (d.type === "ClassDeclaration" && d.id?.name === fnName) return [d];
+    if (d.type === "VariableDeclaration") {
+      for (const dec of d.declarations ?? []) {
+        const id = dec.id;
+        if (id?.name === fnName) return [dec];
+      }
+    }
+  }
+  return void 0;
+}
+function locInSpan(loc, span) {
+  if (!loc || !span) return false;
+  if (loc.line < span.startLine || loc.line > span.endLine) return false;
+  if (loc.line === span.startLine && loc.column < span.startColumn) return false;
+  if (loc.line === span.endLine && loc.column > span.endColumn) return false;
+  return true;
+}
+function isModuleInitLoc(file, loc) {
+  if (!loc) return false;
+  if (!locInSpan(loc, nodeSpan(file.program))) return false;
+  for (const span of deferredExecutionSpans(file)) {
+    if (locInSpan(loc, span)) return false;
+  }
+  return true;
+}
+function definiteModuleThrowOf(file) {
+  return file ? scanDefiniteThrowSeq(file.program.body) : void 0;
+}
+function scanDefiniteThrowSeq(stmts) {
+  for (const stmt of stmts) {
+    const s = stmt;
+    switch (s.type) {
+      case "ThrowStatement": {
+        const at = s.loc?.start;
+        if (at?.line === void 0) return void 0;
+        const kind = thrownKindOf(s.argument);
+        return {
+          line: at.line,
+          column: at.column ?? 0,
+          ...kind !== void 0 ? { kind } : {}
+        };
+      }
+      // 裸块 = 无条件的语句序列 ⇒ 继续下钻
+      case "BlockStatement": {
+        const hit = scanDefiniteThrowSeq(s.body ?? []);
+        if (hit) return hit;
+        continue;
+      }
+      case "ReturnStatement":
+        return void 0;
+      case "IfStatement":
+      case "SwitchStatement":
+      case "TryStatement":
+      case "ForStatement":
+      case "ForInStatement":
+      case "ForOfStatement":
+      case "WhileStatement":
+      case "DoWhileStatement":
+      case "LabeledStatement":
+      case "WithStatement":
+        return void 0;
+      default:
+        continue;
+    }
+  }
+  return void 0;
+}
+function thrownKindOf(arg) {
+  const a = arg;
+  const callee = a?.callee;
+  if (callee?.type !== "Identifier" || typeof callee.name !== "string") return void 0;
+  if (a?.type === "NewExpression") return callee.name;
+  return a?.type === "CallExpression" && callee.name.endsWith("Error") ? callee.name : void 0;
+}
+var TS_ONLY_STATEMENT_REASON_PREFIX = "unsupported:statement:TS";
+function unsupportedFallsInside(file, fnName, reason, loc) {
+  if (!file || !loc) return false;
+  if (!reason.startsWith(TS_ONLY_STATEMENT_REASON_PREFIX) && isModuleInitLoc(file, loc)) {
+    return true;
+  }
+  const entryNodes = entryNodesOf(file, fnName);
+  if (!entryNodes || entryNodes.length === 0) return false;
+  for (const node of entryNodes) {
+    if (locInSpan(loc, nodeSpan(node))) return true;
+  }
+  for (const node of entryNodes) {
+    for (const reach of reachableTopBindings(file, node, { includeClasses: true })) {
+      if (locInSpan(loc, nodeSpan(reach.node))) return true;
+    }
+  }
+  return false;
 }
 
 // src/algebra/check-assign.ts
@@ -1884,6 +2282,8 @@ function widenForAssign(a) {
       const el = els.reduce((x, y) => joinAbs(x, y));
       return abs({ k: "arr", element: el }, void 0, void 0, a.conf);
     }
+    const prim = samePrimOfSum(s.members);
+    if (prim) return abs({ k: "prim", type: prim }, void 0, void 0, a.conf);
     return a;
   }
   if (s.k === "tuple") {
@@ -1935,14 +2335,40 @@ function widenForAssign(a) {
   }
   return a;
 }
+function samePrimOfSum(members) {
+  let out;
+  for (const m of members) {
+    const t = primNameOf(m);
+    if (!t) return void 0;
+    if (out === void 0) out = t;
+    else if (out !== t) return void 0;
+  }
+  return out;
+}
+function primNameOf(a) {
+  if (a.shape.k === "prim") return a.shape.type;
+  const lv = a.term?.op === "lit" ? a.term.value : void 0;
+  if (typeof lv === "string") return "string";
+  if (typeof lv === "number") return "number";
+  if (typeof lv === "boolean") return "boolean";
+  if (typeof lv === "bigint") return "bigint";
+  return void 0;
+}
+function isAbsLike(v2) {
+  return !!v2 && typeof v2 === "object" && "shape" in v2 && "conf" in v2;
+}
+function shapeOnly(a) {
+  return abs(a.shape, void 0, void 0, a.conf);
+}
 function structuralAssignIssues(records) {
   const out = [];
   for (const r of records) {
     if (!r.prev) continue;
+    if (!isAbsLike(r.prev) || !isAbsLike(r.next)) continue;
     if (r.conditional) continue;
     if (r.next.shape.k === "unknown" && !r.next.term) continue;
     if (r.prev.shape.k === "unknown" && !r.prev.term) continue;
-    const leq = leqAbs(widenForAssign(r.next), widenForAssign(r.prev));
+    const leq = leqAbs(widenForAssign(r.next), shapeOnly(widenForAssign(r.prev)));
     if (!leq.ok) {
       out.push({
         severity: "error",
@@ -1961,6 +2387,339 @@ function structuralAssignIssues(records) {
 }
 
 // src/algebra/check-case-scan.ts
+function parseNumericLiteral(text) {
+  const s = text.trim();
+  if (s === "") return void 0;
+  let sign = 1;
+  let body = s;
+  if (body.startsWith("-")) {
+    sign = -1;
+    body = body.slice(1).trimStart();
+  } else if (body.startsWith("+")) {
+    body = body.slice(1).trimStart();
+  }
+  if (body === "") return void 0;
+  if (body.endsWith("n")) {
+    const d = body.slice(0, -1);
+    if (d.includes("_")) return void 0;
+    if (/^0[xX][0-9a-fA-F]+$/.test(d)) return BigInt(d) * BigInt(sign);
+    if (/^0[bB][01]+$/.test(d)) return BigInt(d) * BigInt(sign);
+    if (/^0[oO][0-7]+$/.test(d)) return BigInt(d) * BigInt(sign);
+    if (/^[0-9]+$/.test(d)) return BigInt(d) * BigInt(sign);
+    return void 0;
+  }
+  if (body.includes("__")) return void 0;
+  const clean = body.replace(/_/g, "");
+  if (clean === "") return void 0;
+  if (/^0[xX][0-9a-fA-F]+$/.test(clean)) return sign * Number(BigInt(clean));
+  if (/^0[bB][01]+$/.test(clean)) return sign * Number(BigInt(clean));
+  if (/^0[oO][0-7]+$/.test(clean)) return sign * Number(BigInt(clean));
+  if (clean === "Infinity") return sign * Infinity;
+  if (clean === "NaN") return NaN;
+  if (/^0[0-7]+$/.test(clean) && !body.includes("_")) return sign * parseInt(clean.slice(1), 8);
+  if (/^(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/.test(clean)) return sign * Number(clean);
+  return void 0;
+}
+function parseStringLiteralValue(text) {
+  const t = text.trim();
+  if (t.length < 2) return void 0;
+  const q = t[0];
+  if (q !== '"' && q !== "'") return void 0;
+  if (t[t.length - 1] !== q) return void 0;
+  const inner = t.slice(1, -1);
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === q) return void 0;
+  }
+  let out = "";
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch !== "\\") {
+      out += ch;
+      continue;
+    }
+    const n = inner[i + 1];
+    if (n === void 0) return void 0;
+    i++;
+    switch (n) {
+      case "n":
+        out += "\n";
+        break;
+      case "t":
+        out += "	";
+        break;
+      case "r":
+        out += "\r";
+        break;
+      case "b":
+        out += "\b";
+        break;
+      case "f":
+        out += "\f";
+        break;
+      case "v":
+        out += "\v";
+        break;
+      case "0":
+        out += "\0";
+        break;
+      case "x": {
+        const hex = inner.slice(i + 1, i + 3);
+        if (!/^[0-9a-fA-F]{2}$/.test(hex)) return void 0;
+        out += String.fromCharCode(parseInt(hex, 16));
+        i += 2;
+        break;
+      }
+      case "u": {
+        if (inner[i + 1] === "{") {
+          const end = inner.indexOf("}", i + 1);
+          if (end < 0) return void 0;
+          const hex = inner.slice(i + 2, end);
+          if (!/^[0-9a-fA-F]{1,6}$/.test(hex)) return void 0;
+          out += String.fromCodePoint(parseInt(hex, 16));
+          i = end;
+        } else {
+          const hex = inner.slice(i + 1, i + 5);
+          if (!/^[0-9a-fA-F]{4}$/.test(hex)) return void 0;
+          out += String.fromCharCode(parseInt(hex, 16));
+          i += 4;
+        }
+        break;
+      }
+      case "\n":
+        break;
+      // 行连接
+      case "\r":
+        if (inner[i + 1] === "\n") i++;
+        break;
+      default:
+        out += n;
+        break;
+    }
+  }
+  return out;
+}
+function parseScalarArgAbs(s) {
+  const t = s.trim();
+  if (t === "") return void 0;
+  if (t === "true") return { shape: { k: "prim", type: "boolean" }, term: { op: "lit", value: true }, conf: "exact" };
+  if (t === "false") return { shape: { k: "prim", type: "boolean" }, term: { op: "lit", value: false }, conf: "exact" };
+  if (t === "null") return { shape: { k: "unknown" }, term: { op: "lit", value: null }, conf: "exact" };
+  if (t === "undefined") return { shape: { k: "unknown" }, term: { op: "lit", value: void 0 }, conf: "exact" };
+  const num2 = parseNumericLiteral(t);
+  if (num2 !== void 0) {
+    return typeof num2 === "bigint" ? bigintLit(num2) : numLit(num2);
+  }
+  const str2 = parseStringLiteralValue(t);
+  if (str2 !== void 0) {
+    return {
+      shape: { k: "prim", type: "string" },
+      term: { op: "lit", value: str2 },
+      conf: "exact"
+    };
+  }
+  return void 0;
+}
+function splitCaseArgsText(text) {
+  const result = [];
+  let current = "";
+  let depth = 0;
+  let inString = null;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      current += ch;
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    if (ch === ")" || ch === "]" || ch === "}") depth--;
+    if (ch === "," && depth === 0) {
+      result.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) result.push(current.trim());
+  return result;
+}
+function stripCaseContinuation(text) {
+  return text.split("\n").map((line) => line.replace(/^\s*\*\s?/, "")).join("\n");
+}
+function findTopLevelColon(text) {
+  let found = -1;
+  let depth = 0;
+  let inString = null;
+  for (let i = 0; i < text.length && found < 0; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inString = ch;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth++;
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      continue;
+    }
+    if (ch === ":" && depth === 0) found = i;
+  }
+  return found;
+}
+function parseStructureArgAbs(text) {
+  const t = text.trim();
+  if (t.startsWith("{") && t.endsWith("}")) {
+    const body = t.slice(1, -1).trim();
+    const slots = {};
+    if (body !== "") {
+      for (const entry of splitCaseArgsText(body)) {
+        if (entry === "") continue;
+        const colon = findTopLevelColon(entry);
+        if (colon < 0) return void 0;
+        const keyText = entry.slice(0, colon).trim();
+        if (keyText === "" || keyText.includes("[")) return void 0;
+        const key = keyText.replace(/^["']|["']$/g, "");
+        if (key === "") return void 0;
+        const value = parseCaseArgAbs(entry.slice(colon + 1));
+        if (!value) return void 0;
+        slots[key] = { value };
+      }
+    }
+    return abs({ k: "obj", slots }, void 0, void 0, "exact");
+  }
+  if (t.startsWith("[") && t.endsWith("]")) {
+    const body = t.slice(1, -1).trim();
+    const elements = [];
+    if (body !== "") {
+      for (const el of splitCaseArgsText(body)) {
+        if (el === "") continue;
+        const value = parseCaseArgAbs(el);
+        if (!value) return void 0;
+        elements.push(value);
+      }
+    }
+    return abs({ k: "tuple", elements }, void 0, void 0, "exact");
+  }
+  return void 0;
+}
+function parseCaseArgAbs(text) {
+  return parseScalarArgAbs(text) ?? parseStructureArgAbs(text);
+}
+function isConstraintBuilderArg(text) {
+  return CONSTRAINT_EXPR_RE.test(text.trim());
+}
+function derefDeepConstraint(c) {
+  let cur = c;
+  for (let i = 0; i < LAZY_TEMPLATE_DEPTH && cur.lazy; i++) {
+    cur = derefConstraint(cur);
+  }
+  return cur;
+}
+function witnessNoInfo(w) {
+  const k = w.shape.k;
+  return k === "never" || (k === "unknown" || k === "any") && !w.term;
+}
+function witnessIsStructure(w) {
+  const k = w.shape.k;
+  return k === "obj" || k === "arr" || k === "tuple";
+}
+function witnessPrimType(w) {
+  const shape2 = w.shape.k === "brand" ? w.shape.shape.shape : w.shape;
+  if (shape2.k === "prim") return shape2.type;
+  return void 0;
+}
+function constraintIsAnyLike(c) {
+  return c.prim === void 0 && c.preds.length === 0 && (c.members?.length ?? 0) === 0 && !c.fields && !c.element && !c.fn;
+}
+function witnessViolations(c, w, path, depth) {
+  if (depth > 6) return [];
+  const cc = derefDeepConstraint(c);
+  if (cc.members && cc.members.length > 0) {
+    let first = [];
+    for (const m of cc.members) {
+      const vs = witnessViolations(m, w, path, depth + 1);
+      if (vs.length === 0) return [];
+      if (first.length === 0) first = vs;
+    }
+    return first;
+  }
+  if (cc.fields) {
+    const shape2 = w.shape.k === "brand" ? w.shape.shape.shape : w.shape;
+    if (shape2.k !== "obj") {
+      if (witnessNoInfo(w)) return [];
+      return [{ actual: w, expected: formatConstraint(cc), path, missing: false }];
+    }
+    const out = [];
+    for (const [key, field] of Object.entries(cc.fields)) {
+      const slot = getSlot(shape2.slots, key);
+      const fieldPath = path === "" ? key : `${path}.${key}`;
+      if (!slot) {
+        if (!field.optional && !field.constraint.isOptional) {
+          out.push({
+            actual: w,
+            expected: `missing field ${fieldPath}`,
+            path: fieldPath,
+            missing: true
+          });
+        }
+        continue;
+      }
+      out.push(...witnessViolations(field.constraint, slot.value, fieldPath, depth + 1));
+    }
+    return out;
+  }
+  if (cc.element) {
+    const shape2 = w.shape.k === "brand" ? w.shape.shape.shape : w.shape;
+    const elements = shape2.k === "tuple" ? shape2.elements : shape2.k === "arr" ? [shape2.element] : void 0;
+    if (!elements) {
+      if (witnessNoInfo(w)) return [];
+      return [{ actual: w, expected: formatConstraint(cc), path, missing: false }];
+    }
+    const out = [];
+    elements.forEach((el, i) => {
+      out.push(...witnessViolations(cc.element, el, `${path}[${i}]`, depth + 1));
+    });
+    return out;
+  }
+  if (cc.fn) return [];
+  if (witnessIsStructure(w)) {
+    if (constraintIsAnyLike(cc)) return [];
+    return [{ actual: w, expected: formatConstraint(cc), path, missing: false }];
+  }
+  const argLit = w.term?.op === "lit" ? w.term.value : void 0;
+  if (w.term?.op !== "lit") return [];
+  if (typeof argLit !== "number" && typeof argLit !== "string" && typeof argLit !== "boolean" && argLit !== null && argLit !== void 0) {
+    return [];
+  }
+  if (cc.prim) {
+    const prim = witnessPrimType(w);
+    if (prim !== void 0 && prim !== cc.prim) {
+      return [
+        { actual: w, expected: `typeof ${path} = "${cc.prim}"`, path, missing: false }
+      ];
+    }
+  }
+  if (!literalMeetsConstraint(argLit, cc)) {
+    return [{ actual: w, expected: formatConstraint(cc), path, missing: false }];
+  }
+  return [];
+}
 function projectCaseArgField(arg, fieldPath) {
   let cur = arg;
   for (const seg of fieldPath) {
@@ -1980,57 +2739,6 @@ function scanCaseInconsistency(source, knownFns, opts) {
   const hasContractOrigin = directiveSrc.includes("@nudo:contract") || opts.sidecarPresent === true;
   if (!hasContractOrigin) return out;
   const file = opts.file ?? parseSource(source);
-  const parseLitArg = (s) => {
-    const t = s.trim();
-    if (t === "") return void 0;
-    if (t === "true") return { shape: { k: "prim", type: "boolean" }, term: { op: "lit", value: true }, conf: "exact" };
-    if (t === "false") return { shape: { k: "prim", type: "boolean" }, term: { op: "lit", value: false }, conf: "exact" };
-    if (t === "null") return { shape: { k: "unknown" }, term: { op: "lit", value: null }, conf: "exact" };
-    if (t === "undefined") return { shape: { k: "unknown" }, term: { op: "lit", value: void 0 }, conf: "exact" };
-    if (/^-?\d+(\.\d+)?$/.test(t)) return numLit(Number(t));
-    const str2 = t.match(/^(['"])([\s\S]*)\1$/);
-    if (str2) {
-      return {
-        shape: { k: "prim", type: "string" },
-        term: { op: "lit", value: str2[2] },
-        conf: "exact"
-      };
-    }
-    return void 0;
-  };
-  const parseCaseArgs = (raw) => {
-    const m = raw.match(/@nudo:case\s+"[^"]+"\s*\(([\s\S]*)\)/);
-    if (!m) return void 0;
-    const inner = m[1].trim();
-    if (inner === "") return [];
-    const parts = [];
-    let depth = 0;
-    let cur = "";
-    let quote = null;
-    for (let i = 0; i < inner.length; i++) {
-      const ch = inner[i];
-      if (quote) {
-        cur += ch;
-        if (ch === quote && inner[i - 1] !== "\\") quote = null;
-        continue;
-      }
-      if (ch === '"' || ch === "'") {
-        quote = ch;
-        cur += ch;
-        continue;
-      }
-      if (ch === "(" || ch === "[" || ch === "{") depth++;
-      if (ch === ")" || ch === "]" || ch === "}") depth--;
-      if (ch === "," && depth === 0) {
-        parts.push(cur);
-        cur = "";
-        continue;
-      }
-      cur += ch;
-    }
-    if (cur.trim()) parts.push(cur);
-    return parts;
-  };
   const checkCaseAgainstReqs = (fnName, caseName, args, line) => {
     const g = generalizeFromAst(fnName, source, {
       ...file ? { file } : {},
@@ -2072,20 +2780,45 @@ function scanCaseInconsistency(source, knownFns, opts) {
       ]);
     }
     if (reqs.length === 0) return;
-    const absArgs = args.map((a) => parseLitArg(a) ?? abs({ k: "unknown" }, void 0, void 0, "partial"));
+    const absArgs = args.map((a) => parseCaseArgAbs(a));
     for (const req of reqs) {
       const idx = req[0];
       const entry = req[1];
       const fieldPath = req[2];
-      if (entry.constraint.fields) continue;
+      const paramName = entry.param || paramNames[idx] || `arg${idx}`;
+      if (idx >= args.length) {
+        out.push({
+          severity: "warning",
+          code: DIAG.directiveSyntax,
+          message: `${fnName} case "${caseName}": no witness argument for contract slot ${paramName} (${args.length} argument(s) given)`,
+          actual: `${args.length} argument(s)`,
+          expected: `${idx + 1} argument(s)`,
+          suggestion: `add a witness argument for ${paramName}, or drop the contract on ${paramName}`,
+          fn: fnName,
+          line
+        });
+        continue;
+      }
+      if (absArgs[idx] === void 0) {
+        if (isConstraintBuilderArg(args[idx])) continue;
+        out.push({
+          severity: "warning",
+          code: DIAG.directiveSyntax,
+          message: `${fnName} case "${caseName}": witness argument ${idx + 1} could not be parsed \u2014 contract slot ${paramName} was not checked`,
+          actual: args[idx],
+          expected: "a literal witness (number / string / boolean / null / undefined / object literal / array literal)",
+          suggestion: `use a literal witness for ${paramName}, or relax the refine on ${paramName}`,
+          fn: fnName,
+          line
+        });
+        continue;
+      }
       let arg = absArgs[idx];
-      if (!arg) continue;
       if (fieldPath) {
         const projected = projectCaseArgField(arg, fieldPath);
         if (!projected) {
           const k = arg.shape.k;
           if (k !== "unknown" && k !== "any") {
-            const paramName = entry.param || paramNames[idx] || `arg${idx}`;
             const field = fieldPath.join(".");
             out.push({
               severity: "error",
@@ -2102,6 +2835,22 @@ function scanCaseInconsistency(source, knownFns, opts) {
         }
         arg = projected;
       }
+      const cc = derefDeepConstraint(entry.constraint);
+      if (cc.fields || witnessIsStructure(arg)) {
+        for (const v2 of witnessViolations(cc, arg, "", 0)) {
+          out.push({
+            severity: "error",
+            code: DIAG.caseInconsistency,
+            message: `${fnName} case "${caseName}": witness \u22AD contract`,
+            actual: formatAbs(v2.actual),
+            expected: v2.expected,
+            suggestion: v2.missing ? `add the missing field ${v2.path} to the case argument (contract slot ${paramName})` : `change the case argument, or relax the refine on ${paramName}`,
+            fn: fnName,
+            line
+          });
+        }
+        continue;
+      }
       const argLit = arg.term?.op === "lit" ? arg.term.value : void 0;
       const argIsLit = arg.term?.op === "lit";
       if (!argIsLit || typeof argLit !== "number" && typeof argLit !== "string" && typeof argLit !== "boolean" && argLit !== null && argLit !== void 0) {
@@ -2110,7 +2859,6 @@ function scanCaseInconsistency(source, knownFns, opts) {
       const hasEqOr = (entry.constraint.members?.length ?? 0) > 0 || entry.constraint.preds.some((p) => p.op === "eq");
       if (hasEqOr) {
         if (!literalMeetsConstraint(argLit, entry.constraint)) {
-          const paramName = entry.param || paramNames[idx] || `arg${idx}`;
           out.push({
             severity: "error",
             code: DIAG.caseInconsistency,
@@ -2126,7 +2874,6 @@ function scanCaseInconsistency(source, knownFns, opts) {
       }
       if (typeof argLit !== "number") continue;
       if (isIntFlag(entry.constraint) && !Number.isInteger(argLit)) {
-        const paramName = entry.param || paramNames[idx] || `arg${idx}`;
         out.push({
           severity: "error",
           code: DIAG.caseInconsistency,
@@ -2148,7 +2895,6 @@ function scanCaseInconsistency(source, knownFns, opts) {
           if (p.op === "lt") ok = argLit < n;
           if (p.op === "le") ok = argLit <= n;
           if (!ok) {
-            const paramName = entry.param || paramNames[idx] || `arg${idx}`;
             out.push({
               severity: "error",
               code: DIAG.caseInconsistency,
@@ -2170,8 +2916,7 @@ function scanCaseInconsistency(source, knownFns, opts) {
       const text = scope.commentTexts[ci];
       const startLine = scope.commentStartLines[ci] ?? 0;
       for (const tag of scanCaseTags(text)) {
-        const caseArgs = parseCaseArgs(`@nudo:case "${tag.name}" (${tag.argsText})`);
-        if (!caseArgs) continue;
+        const caseArgs = splitCaseArgsText(stripCaseContinuation(tag.argsText));
         checkCaseAgainstReqs(scope.name, tag.name, caseArgs, startLine);
       }
     }
@@ -2187,18 +2932,27 @@ function checkSource(filePath, source, phi = pTrue, opts = {}) {
 }
 function checkSourceInScope(filePath, source, phi, opts) {
   let callOpts = opts;
+  const loadReadFailures = [];
+  const loadFailureKeys = /* @__PURE__ */ new Set();
+  let speculativeLoad;
   if (opts.loadModule && opts.fromFile) {
     const loadCache = /* @__PURE__ */ new Map();
     const raw = opts.loadModule;
-    const fromFile = opts.fromFile;
+    const cachedLoad = (spec, from) => {
+      const k = `${from}\0${spec}`;
+      if (!loadCache.has(k)) loadCache.set(k, raw(spec, from));
+      return loadCache.get(k);
+    };
     callOpts = {
       ...opts,
-      loadModule: (spec, from) => {
-        const k = `${from}\0${spec}`;
-        if (!loadCache.has(k)) loadCache.set(k, raw(spec, from));
-        return loadCache.get(k);
-      }
+      loadModule: guardLoadModule(cachedLoad, (failure) => {
+        const key = `${failure.path}\0${failure.code}`;
+        if (loadFailureKeys.has(key)) return;
+        loadFailureKeys.add(key);
+        loadReadFailures.push(failure);
+      })
     };
+    speculativeLoad = cachedLoad;
   }
   setRefineDiagCollector(null);
   setInterfaceDiagCollector(null);
@@ -2208,11 +2962,20 @@ function checkSourceInScope(filePath, source, phi, opts) {
   const useMemo = phi.op === "true";
   let memoKey;
   const stable = stableAnalyzeKeySource(source);
-  const depsFp = checkDepsFingerprint(stable, callOpts);
-  const sidecarFp = callOpts.loadModule && callOpts.fromFile ? sidecarClosureFingerprint(callOpts.fromFile, callOpts) : void 0;
+  const depsFp = callOpts.loadModule && callOpts.fromFile ? loadModuleDepsFingerprint(stable, callOpts.loadModule, callOpts.fromFile, {
+    ...speculativeLoad ? { ambientLoadModule: speculativeLoad } : {},
+    ambientAllowed: (sidecarPath) => sidecarAutoBindAllowed(sidecarPath, opts.autoBind, opts.projectDir)
+  }) : { fp: "-", paths: [], contents: [], truncated: false, readError: false };
+  const sidecarFp = callOpts.loadModule && callOpts.fromFile ? sidecarClosureFingerprint(callOpts.fromFile, {
+    ...callOpts,
+    ...speculativeLoad ? { loadModule: speculativeLoad } : {}
+  }) : void 0;
   const allowMemo = useMemo && !depsFp.truncated && // 读错误轮键不可信（#135）：错误轮报告（nudo:interface-load）与真 miss 轮
   // （干净）若共享 miss 键会互为跨次陈旧命中——不读也不写 memo
-  !depsFp.readError && !(sidecarFp?.startsWith("trunc:") ?? false);
+  !depsFp.readError && // Bug 499：本闸把读失败降级成 miss（指纹面看不到 readError）——但
+  // 「不可读」轮与「真不存在」轮的报告不同（前者多一条读失败诊断），
+  // 共用同一键会互为陈旧命中 ⇒ 读失败轮一律不碰 memo。
+  loadReadFailures.length === 0 && !(sidecarFp?.startsWith("trunc:") ?? false);
   if (allowMemo) {
     memoKey = checkMemoKey(filePath, stable, opts, depsFp, sidecarFp);
     const hit = checkMemoGet(memoKey);
@@ -2225,7 +2988,10 @@ function checkSourceInScope(filePath, source, phi, opts) {
   const issues = [];
   const signatures = [];
   const file = parseSource(source);
-  const names = listTopFunctions(source, file);
+  const names = [
+    ...listTopFunctions(source, file),
+    ...listClassEntryNames(source, file)
+  ];
   const memoPaths = sidecarFp !== void 0 && callOpts.fromFile ? [.../* @__PURE__ */ new Set([...depsFp.paths, normPath(sidecarPathOf(callOpts.fromFile))])] : depsFp.paths;
   const truncated = /* @__PURE__ */ new Map();
   resetAbsCallBudget();
@@ -2239,7 +3005,7 @@ function checkSourceInScope(filePath, source, phi, opts) {
       makeSameFileFaceResolver(callOpts, filePath, source, file)
     );
     try {
-      attachCrossModuleContractFaces(callOpts, filePath);
+      const crossModuleIssues = attachCrossModuleContractFaces(callOpts, filePath);
       const report = checkSourceInner(
         filePath,
         source,
@@ -2258,8 +3024,10 @@ function checkSourceInScope(filePath, source, phi, opts) {
         ...takeRefineDiagsSince(refineSince),
         ...takeInterfaceDiagsSince(ifaceSince)
       ]);
-      if (diagIssues.length > 0) {
-        report.issues.push(...diagIssues);
+      const loadIssues = loadReadFailureIssues(loadReadFailures);
+      const allIssues = [...diagIssues, ...loadIssues, ...crossModuleIssues];
+      if (allIssues.length > 0) {
+        report.issues.push(...allIssues);
         const errors = report.issues.filter((i) => i.severity === "error").length;
         const warnings = report.issues.filter((i) => i.severity === "warning").length;
         const infos = report.issues.filter((i) => i.severity === "info").length;
@@ -2271,7 +3039,9 @@ function checkSourceInScope(filePath, source, phi, opts) {
           functions: report.summary.functions
         };
       }
-      if (memoKey) checkMemoSet(memoKey, report, memoPaths);
+      if (memoKey && loadReadFailures.length === 0) {
+        checkMemoSet(memoKey, report, memoPaths);
+      }
       return cloneCheckReport(report);
     } finally {
       setContractFaceResolver(prevFaceResolver);
@@ -2280,6 +3050,14 @@ function checkSourceInScope(filePath, source, phi, opts) {
     setAbsTruncationCollector(prevTrunc);
   }
 }
+function loadReadFailureIssues(failures) {
+  return failures.map((f) => ({
+    severity: "error",
+    code: DIAG.moduleUnreadable,
+    message: `cannot read module '${f.path}' (${f.code}): ${f.message}`,
+    suggestion: "fix the file permissions (or the module path) \u2014 the dependency is present but unreadable, so its types are unknown"
+  }));
+}
 function makeSameFileFaceResolver(opts, filePath, source, file) {
   const loadModule = opts.loadModule;
   const fromFile = opts.fromFile ?? filePath;
@@ -2307,24 +3085,48 @@ function makeSameFileFaceResolver(opts, filePath, source, file) {
     return faces;
   };
 }
+function unmatchedContractParams(eff, formalDisplay, formals) {
+  const contractNames = contractParamNameSet(formals);
+  const display = new Set(formalDisplay);
+  const conflictNames = new Set(eff.conflict?.params ?? []);
+  return eff.params.map((p) => p.param).filter(
+    (p) => p && !display.has(p) && !contractNames.has(p) && !conflictNames.has(p)
+  );
+}
+function paramMismatchIssue(name, unknownParams, formalDisplay, formals) {
+  const contractNames = contractParamNameSet(formals);
+  const surface = [...contractNames].filter((n) => !n.startsWith("_p") && n !== "_").join(", ");
+  return {
+    severity: "error",
+    code: DIAG.interfaceParamMismatch,
+    message: `${name}: contract parameter name(s) not in the formal parameter list (${unknownParams.join(", ")})`,
+    actual: unknownParams.join(", "),
+    expected: surface || formalDisplay.join(", ") || "(no params)",
+    suggestion: `rename the @nudo:contract / sidecar binding parameter to one of: ${surface || formalDisplay.join(", ") || "(function has no params)"}`,
+    fn: name
+  };
+}
 function attachCrossModuleContractFaces(opts, filePath) {
   const loadModule = opts.loadModule;
   const fromFile = opts.fromFile ?? filePath;
-  if (!loadModule) return;
+  if (!loadModule) return [];
   const tables = [];
   for (const t of [opts.modules, opts.inject?.modules]) {
     if (t && typeof t === "object" && !tables.includes(t)) tables.push(t);
   }
-  if (tables.length === 0) return;
+  if (tables.length === 0) return [];
   const autoBind = opts.autoBind;
   const projectDir = opts.projectDir;
+  const mismatchIssues = [];
   const facesCache = /* @__PURE__ */ new Map();
   const facesFor = (depSource, depPath, name, paramNames) => {
     const key = `${depPath}\0${name}`;
-    if (facesCache.has(key)) return facesCache.get(key);
+    const hit = facesCache.get(key);
+    if (hit) return hit;
     let faces;
+    let eff;
     try {
-      const eff = effectiveInterface(depSource, name, {
+      eff = effectiveInterface(depSource, name, {
         loadModule,
         fromFile: depPath,
         ...autoBind !== void 0 ? { autoBind } : {},
@@ -2333,22 +3135,36 @@ function attachCrossModuleContractFaces(opts, filePath) {
       if (eff) faces = contractFacesFromEffectiveInterface(eff, paramNames);
     } catch {
       faces = void 0;
+      eff = void 0;
     }
-    facesCache.set(key, faces);
-    return faces;
+    const out = { faces, eff };
+    facesCache.set(key, out);
+    return out;
   };
   const attachFnAbs = (v2, depSource, depPath, name) => {
     if (!v2 || typeof v2 !== "object" || !("shape" in v2)) return;
     const shape2 = v2.shape;
     if (shape2.k !== "fn") return;
-    let paramNames;
+    let paramNames = [];
+    let formals = [];
     try {
-      paramNames = extractFn(depSource, name)?.params ?? [];
+      const meta = extractFn(depSource, name);
+      paramNames = meta?.params ?? [];
+      formals = meta?.formals ?? [];
     } catch {
       paramNames = [];
+      formals = [];
     }
-    const faces = facesFor(depSource, depPath, name, paramNames);
+    const { faces, eff } = facesFor(depSource, depPath, name, paramNames);
     if (faces) attachContractFaces(v2, faces);
+    if (eff?.source === "handwritten") {
+      const unknownParams = unmatchedContractParams(eff, paramNames, formals);
+      if (unknownParams.length > 0) {
+        mismatchIssues.push(
+          paramMismatchIssue(name, unknownParams, paramNames, formals)
+        );
+      }
+    }
   };
   for (const table of tables) {
     for (const [spec, mod2] of Object.entries(table)) {
@@ -2370,6 +3186,7 @@ function attachCrossModuleContractFaces(opts, filePath) {
       if (def !== void 0) attachFnAbs(def, depSource, depPath, "default");
     }
   }
+  return mismatchIssues;
 }
 function sidecarDiagIssues(diags) {
   const seen = /* @__PURE__ */ new Set();
@@ -2379,7 +3196,14 @@ function sidecarDiagIssues(diags) {
     if (seen.has(k)) continue;
     seen.add(k);
     const severity = d.code === DIAG.contractSyntax || d.code === DIAG.directiveSyntax ? "warning" : "error";
-    out.push({ severity, code: d.code, message: d.message });
+    out.push({
+      severity,
+      code: d.code,
+      message: d.message,
+      // Bug 374：位置透传（nudo:contract-syntax 不再落在文件第 1 行第 1 列）
+      ...d.line !== void 0 ? { line: d.line } : {},
+      ...d.column !== void 0 ? { column: d.column } : {}
+    });
   }
   return out;
 }
@@ -2397,6 +3221,7 @@ function assumePremisesPhiOf(name, source, file, issues) {
   const preds = [];
   const display = [];
   for (const seg of segs) {
+    const pos = seg.line !== void 0 ? { line: seg.line, ...seg.column !== void 0 ? { column: seg.column } : {} } : {};
     if (seg.kind === "bad") {
       issues.push({
         severity: "error",
@@ -2405,7 +3230,8 @@ function assumePremisesPhiOf(name, source, file, issues) {
         actual: seg.raw,
         expected: "<param> <= <param>",
         suggestion: "cross-variable lemmas: @nudo:assume d <= max \u2014 constant bounds: sidecar number().le(10)",
-        fn: name
+        fn: name,
+        ...pos
       });
       continue;
     }
@@ -2418,7 +3244,8 @@ function assumePremisesPhiOf(name, source, file, issues) {
         actual: bad.join(", "),
         expected: surface || "(no params/locals)",
         suggestion: `reference one of: ${surface || "(no params or top-level locals)"}`,
-        fn: name
+        fn: name,
+        ...pos
       });
       continue;
     }
@@ -2426,7 +3253,7 @@ function assumePremisesPhiOf(name, source, file, issues) {
     display.push(`${seg.lhs} <= ${seg.rhs}`);
   }
   if (preds.length === 0) return void 0;
-  return { phi: and(...preds), display };
+  return { phi: and(...preds), display, premises: preds };
 }
 function invariantSpecsOf(name, source, file, issues) {
   const segs = extractInvariantSegs(source, name);
@@ -2441,6 +3268,7 @@ function invariantSpecsOf(name, source, file, issues) {
   const specs = [];
   const display = [];
   for (const seg of segs) {
+    const pos = seg.line !== void 0 ? { line: seg.line, ...seg.column !== void 0 ? { column: seg.column } : {} } : {};
     if (seg.kind === "bad") {
       issues.push({
         severity: "warning",
@@ -2449,7 +3277,8 @@ function invariantSpecsOf(name, source, file, issues) {
         actual: seg.raw,
         expected: "<name><path> <rel> <number>",
         suggestion: "loop-carried bounds: @nudo:invariant dp[*][*] >= 0 \u2014 scalar: @nudo:invariant last >= 1",
-        fn: name
+        fn: name,
+        ...pos
       });
       continue;
     }
@@ -2461,7 +3290,8 @@ function invariantSpecsOf(name, source, file, issues) {
         actual: seg.name,
         expected: surface || "(no params/locals)",
         suggestion: `reference one of: ${surface || "(no params or top-level locals)"}`,
-        fn: name
+        fn: name,
+        ...pos
       });
       continue;
     }
@@ -2471,6 +3301,36 @@ function invariantSpecsOf(name, source, file, issues) {
   if (specs.length === 0) return void 0;
   return { specs, display };
 }
+function dedupeAssignRecords(records) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const r of records) {
+    const key = JSON.stringify([
+      r.name,
+      r.line ?? "",
+      r.column ?? "",
+      r.conditional ? "1" : "0",
+      assignValueKey(r.prev),
+      assignValueKey(r.next)
+    ]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(r);
+  }
+  return out;
+}
+function assignValueKey(v2) {
+  if (v2 === void 0) return "-";
+  if (v2 === null) return "null";
+  if (typeof v2 !== "object") return `host:${typeof v2}:${String(v2)}`;
+  const o = v2;
+  if (!("shape" in o) || !("conf" in o)) return `host:${typeof v2}`;
+  try {
+    return formatAbs(v2);
+  } catch {
+    return `abs:${o.shape?.k ?? "?"}:${o.conf ?? "?"}`;
+  }
+}
 var OPAQUE_EVIDENCE_HINT = "add @nudo:case or a call site";
 var OPAQUE_ENV_HINT = "declare the runtime env to type native modules: '/// @nudo:env node' (or web/es) \u2014 see guides/env-harvest.md";
 function isBuiltinModuleSpec(spec) {
@@ -2505,9 +3365,12 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
     eiCache.set(key, eff);
     return eff;
   };
+  const records = [];
+  const prevAssign = setEvalAssignCollector((r) => records.push(r));
   for (const name of names) {
     const assumePhi = assumePremisesPhiOf(name, source, file, issues);
     const inv = invariantSpecsOf(name, source, file, issues);
+    resetAssumeConsumed();
     const runSeeded = (body) => {
       if (assumePhi === void 0 && inv === void 0) return body();
       return withAssumePremises(assumePhi?.phi ?? pTrue, () => withInvariantSpecs(inv?.specs ?? [], body));
@@ -2525,6 +3388,7 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
           contractParam.set(p.param, constraintToEntryAbs(p.constraint, p.param));
         }
       }
+      const skipFmt = formatSigCached(retAbs, name);
       signatures.push({
         name,
         params,
@@ -2533,8 +3397,8 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
           return a ? formatShape(a) : "any";
         }),
         abs: retAbs,
-        display: formatAbs(retAbs),
-        detail: formatAbsMultiline(retAbs, name),
+        display: skipFmt.display,
+        detail: skipFmt.detail,
         conf: retAbs.conf,
         ...isEntryFn ? { entry: true } : {}
       });
@@ -2544,12 +3408,29 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
           fromFile: refineFrom
         });
         const display = named?.name ?? formatConstraint(eff.returns.constraint);
-        returnContracts.set(name, { display, constraint: eff.returns.constraint });
+        const contractSource = named ? "directive" : "sidecar";
+        returnContracts.set(name, {
+          display,
+          constraint: eff.returns.constraint,
+          source: contractSource
+        });
         const retIssues = checkReturnConstraint(
           name,
           display,
           eff.returns.constraint,
-          declared
+          declared,
+          {
+            // #369 / #372：issue 构造处带函数声明位置
+            loc: findFnLoc(file, name),
+            source: contractSource,
+            // Bug 1094：返回点的路径前提 Φ（用户引理前提）——skip 分支同样
+            // 透传（函数级公理在 skip 面也成立；证明通道按「同项 ∧ 蕴含」
+            // 口径消费 ⇒ 不会凭空制造确定违约）。assumeDisplay 一并带上 ⇒
+            // Φ 被消费时归因（nudo:assume-relied）仍然可见（不得静默消费）。
+            phi: assumePhi?.phi,
+            phiPremises: assumePhi?.premises,
+            assumeDisplay: assumePhi?.display
+          }
         );
         if (retIssues.some((i) => i.severity === "error")) returnViolated.add(name);
         issues.push(...retIssues);
@@ -2587,7 +3468,7 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
         };
         const effects = collectEntryMayThrows(source, name, synthetic, file, phi, opts);
         const throwsDisplayFallback = formatThrowsAbs(mayThrowEffectsToAbs(effects));
-        const declared = extractDeclaredThrows(source, name) ?? effectiveInterfaceCached(name)?.throws?.kinds;
+        const declared = declaredThrowsForEntry(source, name) ?? effectiveInterfaceCached(name)?.throws?.kinds;
         const remaining = filterGateThrows(effects, declared, ignoreThrows);
         const gateDisplay = formatThrowsAbs(mayThrowEffectsToAbs(remaining));
         if (gateDisplay && remaining.length > 0) {
@@ -2632,7 +3513,7 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
     if (isEntry && entryThrowsMode !== "off") {
       const effects = runSeeded(() => collectEntryMayThrows(source, name, g, file, phi, opts));
       throwsDisplay = formatThrowsAbs(mayThrowEffectsToAbs(effects));
-      const declared = extractDeclaredThrows(source, name) ?? effectiveInterfaceCached(name)?.throws?.kinds;
+      const declared = declaredThrowsForEntry(source, name) ?? effectiveInterfaceCached(name)?.throws?.kinds;
       const remaining = filterGateThrows(effects, declared, ignoreThrows);
       const gateDisplay = formatThrowsAbs(mayThrowEffectsToAbs(remaining));
       if (gateDisplay && remaining.length > 0) {
@@ -2658,7 +3539,7 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
     const paramTypes = g.typeParams.map((t) => {
       if (!t.value) return "any";
       if (t.value.shape.k === "unknown") return "unknown";
-      return formatShape(t.value);
+      return formatEntryParamShape(t.value);
     });
     signatures.push({
       name,
@@ -2678,7 +3559,12 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
       // 的排除一致。
       (t) => t.value && t.value.shape.k === "unknown" && t.value.term?.op !== "lit"
     );
-    const budgetExplained = truncated.has(name) || g.symbolic?.conf === "opaque" || g.symbolic?.shape?.k === "sum" && g.symbolic.shape.members.every((m) => m.shape.k === "unknown" || m.shape.k === "any");
+    const budgetExplained = truncated.has(name) || // Bug 389：`conf=opaque` 通常意味着「路径没覆盖」⇒ 已解释；但**因 env
+    // 门禁而 opaque**（源码声明了 `@nudo:env` 而那个 env 没解析出全局 ⇒
+    // 函数体 fail-closed）不是「已解释」——那正是「推断没成功」，唯一能提示
+    // 它的 `nudo:unknown-inference` 不能被吞（否则用户把 env 名写错的那一刻，
+    // 唯一的失败信号恰好消失）。
+    g.symbolic?.conf === "opaque" && !g.envGated || g.symbolic?.shape?.k === "sum" && g.symbolic.shape.members.every((m) => m.shape.k === "unknown" || m.shape.k === "any");
     const symbolicTrueUnknown = g.symbolic?.shape?.k === "unknown" && g.symbolic.term?.op !== "lit";
     if ((symbolicTrueUnknown || unknownParamIdx >= 0) && !budgetExplained) {
       const where = symbolicTrueUnknown ? `${name} => unknown` : `${name} param ${g.params[unknownParamIdx] ?? `#${unknownParamIdx}`}: unknown`;
@@ -2688,32 +3574,32 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
         message: `${name}: signature has true unknown (inference failed)`,
         actual: where,
         expected: "computable Abs (any = unconstrained, unknown = engine debt)",
-        suggestion: "add @nudo:case / env mock / refine, or confirm the body is algebraically evaluable",
+        // Bug 1062（族 46）：本诊断此前把「`@nudo:replace` 的目标文本没命中」
+        // 说成「推断精度不够」⇒ 归因错误 ⇒ 用户只看到 unknown-inference。
+        // service 侧已加「点名目标文本」的显式诊断（`nudo:directive-syntax`），
+        // 这里补一句归因提示，把「指令没生效」这条可能性点出来。
+        suggestion: "add @nudo:case / env mock / refine, or confirm the body is algebraically evaluable; if you used @nudo:replace, check the target text matches the source",
         fn: name
       });
     }
     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)
-        );
+        const unknownParams = unmatchedContractParams(eff, g.params, g.formals ?? []);
         if (unknownParams.length > 0) {
-          const surface = [...contractNames].filter((n) => !n.startsWith("_p") && n !== "_").join(", ");
-          issues.push({
-            severity: "error",
-            code: DIAG.interfaceParamMismatch,
-            message: `${name}: contract parameter name(s) not in the formal parameter list (${unknownParams.join(", ")})`,
-            actual: unknownParams.join(", "),
-            expected: surface || g.params.join(", ") || "(no params)",
-            suggestion: `rename the @nudo:contract / sidecar binding parameter to one of: ${surface || g.params.join(", ") || "(function has no params)"}`,
-            fn: name
-          });
+          issues.push(
+            paramMismatchIssue(name, unknownParams, g.params, g.formals ?? [])
+          );
         }
       }
+      const contractLocs = contractSegmentLocs(source, name);
+      const locOf = (param) => {
+        const hit = contractLocs.find((c) => {
+          const head = c.segment.trim().split(/\s+/)[0];
+          return head === param;
+        });
+        return hit?.loc ? { line: hit.loc.line, ...hit.loc.column !== void 0 ? { column: hit.loc.column } : {} } : {};
+      };
       if (eff?.conflict) {
         if (eff.conflict.params.length > 0) {
           issues.push({
@@ -2721,7 +3607,8 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
             code: DIAG.interfaceConflict,
             message: `${name}: handwritten contract conjunction unsatisfiable (${eff.conflict.params.join(", ")})`,
             suggestion: "check whether the source @nudo:contract and the same-name sidecar binding have contradictory constant bounds",
-            fn: name
+            fn: name,
+            ...locOf(eff.conflict.params[0])
           });
         }
         if (eff.conflict.returns) {
@@ -2730,24 +3617,70 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
             code: DIAG.interfaceConflict,
             message: `${name}: handwritten contract conjunction unsatisfiable on the return slot`,
             suggestion: "check whether the source @nudo:contract return and the sidecar fn() return constraint are contradictory (the return slot is not enforced when they are)",
-            fn: name
+            fn: name,
+            ...locOf("return")
           });
         }
       }
+      const undecidable = eff?.undecidable;
+      if (undecidable !== void 0 && undecidable.params.length > 0) {
+        issues.push({
+          severity: "warning",
+          code: DIAG.interfaceConflict,
+          message: `${name}: contract conjunction not computable (${undecidable.params.join(", ")}) \u2014 only one side is enforced`,
+          suggestion: "structural contracts (shape / array / union / fn) cannot be combined in this slot; the other side's obligations are NOT enforced \u2014 merge them by hand",
+          fn: name,
+          ...locOf(undecidable.params[0])
+        });
+      }
+      if (undecidable?.returns) {
+        issues.push({
+          severity: "warning",
+          code: DIAG.interfaceConflict,
+          message: `${name}: contract conjunction not computable on the return slot \u2014 only one side is enforced`,
+          suggestion: "structural return constraints cannot be combined in this slot; the other side's obligations are NOT enforced \u2014 merge them by hand",
+          fn: name,
+          ...locOf("return")
+        });
+      }
       if (eff && eff.source === "handwritten" && eff.returns && !eff.conflict?.returns) {
         const named = extractRefineReturnFromSource(source, name, {
           loadModule: refineLoad,
           fromFile: refineFrom
         });
         const display = named?.name ?? formatConstraint(eff.returns.constraint);
-        returnContracts.set(name, { display, constraint: eff.returns.constraint });
+        const contractSource = named ? "directive" : "sidecar";
+        returnContracts.set(name, {
+          display,
+          constraint: eff.returns.constraint,
+          source: contractSource
+        });
+        const consumedAssume = assumePhi ? new Set(
+          assumePhi.display.filter(
+            (_, i) => assumeConsumed().includes(assumePhi.premises[i])
+          )
+        ) : void 0;
         const retIssues = checkReturnConstraint(
           name,
           display,
           eff.returns.constraint,
           g.symbolic,
-          assumePhi?.display,
-          inv?.display
+          {
+            // #369 / #372：issue 构造处带函数声明位置
+            loc: findFnLoc(file, name),
+            source: contractSource,
+            assumeDisplay: assumePhi?.display,
+            invariantDisplay: inv?.display,
+            consumedAssume,
+            // Bug 1094：返回点的**路径前提 Φ** = 用户引理前提
+            //（`@nudo:assume` 的前提 Φ）——证明通道的 Φ 侧。
+            // 项身份：前提项用**真实形参名**（`termVar(name)`），泛化后的返回
+            // 项在形参**有契约**时同样锚在真实名上（`constraintToEntryAbs`）
+            // ⇒ 同项判定能对上；无契约时返回项锚在 α 名（A1…）⇒ 对不上 ⇒
+            // Φ 侧不生效（保守少证，不假红）。
+            phi: assumePhi?.phi,
+            phiPremises: assumePhi?.premises
+          }
         );
         if (retIssues.some((i) => i.severity === "error")) returnViolated.add(name);
         issues.push(...retIssues);
@@ -2760,7 +3693,7 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
         });
       }
     }
-    if (g.symbolic.conf === "opaque" && !truncated.has(name)) {
+    if (g.symbolic.conf === "opaque" && !truncated.has(name) && !g.envGated) {
       issues.push({
         severity: "info",
         code: DIAG.opaqueResult,
@@ -2839,16 +3772,19 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
       fn: label
     });
   }
-  const records = [];
   const varAbs = /* @__PURE__ */ new Map();
   const callRecords = [];
   const bCalls = [];
-  const prevAssign = setEvalAssignCollector((r) => records.push(r));
   const prevCall = setEvalCallCollector((r) => bCalls.push(r));
   let evalBindings;
   const evalAnalyze = evalAnalyzeOpts(opts);
+  let moduleThrow;
   try {
-    const evalRun = tryRunTranspiled(source, evalAnalyze);
+    const evalAttempt = tryRunTranspiledDetailed(source, evalAnalyze);
+    const evalRun = evalAttempt.run;
+    if (evalRun === void 0 && evalAttempt.fallback?.reason === "module-throw") {
+      moduleThrow = definiteModuleThrowOf(file);
+    }
     evalBindings = evalRun ? bindingsOf(evalRun) : void 0;
     if (evalBindings) {
       for (const [k, v2] of evalBindings) {
@@ -2871,6 +3807,22 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
     setEvalCallCollector(prevCall);
   }
   void evalBindings;
+  if (moduleThrow !== void 0 && entryThrowsMode !== "off") {
+    const kind = moduleThrow.kind;
+    if (kind === void 0 || !isThrowsIgnored(kind, ignoreThrows)) {
+      const thrown = kind !== void 0 ? ` ${kind}` : "";
+      issues.push({
+        severity: entryThrowsMode === "warning" ? "warning" : "error",
+        code: DIAG.moduleThrow,
+        message: `module initializer always throws${thrown} \u2014 the module cannot be imported, so every export is unavailable (module not analyzed)`,
+        actual: `throw at line ${moduleThrow.line}`,
+        expected: "module initializer that can complete, or a conditional throw",
+        suggestion: kind !== void 0 ? `guard the throw if the module should be importable; if throwing at load is intended, ignore it with --ignore-throws ${kind} (or --entry-throws off)` : "guard the throw if the module should be importable; --entry-throws off disables this gate",
+        line: moduleThrow.line,
+        column: moduleThrow.column
+      });
+    }
+  }
   const callIssues = canSkipLiteralCallScan(source, file) ? [] : scanLiteralCalls(source, names, phi, {
     loadModule: opts.loadModule,
     // 与 generalize / 返回后置同一 fromFile 口径：ambient 侧车按真实
@@ -2896,15 +3848,22 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
         rec.fnName,
         rc.display,
         rc.constraint,
-        rec.result
+        rec.result,
+        {
+          // #369 / #372：issue 构造处带函数声明位置（被违约函数的声明处）
+          loc: findFnLoc(file, rec.fnName),
+          // #378：约束来源随 returnContracts 走（源码指令 vs 侧车 fn() 返回槽）
+          source: rc.source
+        }
       );
       if (retIssues.some((i) => i.severity === "error")) returnViolated.add(rec.fnName);
       issues.push(...retIssues);
     }
   }
   if (driftCandidates.length > 0) {
+    const driftRecords = opts.from && opts.from.length > 0 ? [...callRecords, ...opts.from.map((r) => ({ fnName: r.fnName, args: r.args, result: r.result }))] : callRecords;
     issues.push(
-      ...interfaceDriftIssues(driftCandidates, callRecords, /* @__PURE__ */ (() => {
+      ...interfaceDriftIssues(driftCandidates, driftRecords, /* @__PURE__ */ (() => {
         let driftRun;
         let driftInit = false;
         return (fnName, args) => {
@@ -2934,7 +3893,16 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
       ...opts.inject ? { inject: opts.inject } : {}
     })
   );
-  issues.push(...structuralAssignIssues(records));
+  try {
+    issues.push(...structuralAssignIssues(dedupeAssignRecords(records)));
+  } catch (err) {
+    issues.push({
+      severity: "warning",
+      code: DIAG.internal,
+      message: `assign channel check failed: ${err.message}`,
+      suggestion: "this is an internal error; please report it together with the checked source file"
+    });
+  }
   const errors = issues.filter((i) => i.severity === "error").length;
   const warnings = issues.filter((i) => i.severity === "warning").length;
   const infos = issues.filter((i) => i.severity === "info").length;
@@ -2948,60 +3916,6 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
     budget: { ...budget }
   };
 }
-function checkReturnConstraint(fnName, cName, constraint, ret, assumeDisplay, invariantDisplay) {
-  const proof = assertImplies(ret, constraint);
-  if (proof.status === "proved") {
-    const relied = [];
-    if (assumeDisplay && assumeDisplay.length > 0) {
-      relied.push({
-        severity: "info",
-        code: DIAG.assumeRelied,
-        message: `${fnName}: return contract proved via @nudo:assume ${assumeDisplay.join("; ")}`,
-        actual: `proof relies on user lemma${assumeDisplay.length > 1 ? "s" : ""}`,
-        expected: "engine verifies the obligation, not the lemma itself",
-        suggestion: "@nudo:assume is a user-supplied axiom \u2014 falsify it with concrete @nudo:case runs (nudo test)",
-        fn: fnName
-      });
-    }
-    if (invariantDisplay && invariantDisplay.length > 0) {
-      relied.push({
-        severity: "info",
-        code: DIAG.invariantRelied,
-        message: `${fnName}: return contract proved via @nudo:invariant ${invariantDisplay.join("; ")}`,
-        actual: `proof relies on user invariant${invariantDisplay.length > 1 ? "s" : ""}`,
-        expected: "engine verifies the obligation, not the loop invariant itself",
-        suggestion: "@nudo:invariant is a user-supplied axiom \u2014 falsify it with concrete @nudo:case runs (nudo test)",
-        fn: fnName
-      });
-    }
-    return relied;
-  }
-  const push = (severity, actual, expected, suggestion) => [
-    {
-      severity,
-      code: severity === "error" ? DIAG.constraintViolated : DIAG.unprovenReturn,
-      message: `${fnName}: return value \u22AD @nudo:contract return ${cName}`,
-      actual,
-      expected,
-      suggestion,
-      fn: fnName
-    }
-  ];
-  if (proof.status === "disproved") {
-    return push(
-      "error",
-      formatAbs(ret),
-      proof.reason,
-      proof.reason.includes("nullish") ? `use nullable(${formatConstraint(constraint)}) or union(..., lit(null)) to allow nullish returns` : `return a value satisfying ${formatConstraint(constraint)}`
-    );
-  }
-  return push(
-    "warning",
-    formatAbs(ret),
-    formatConstraint(constraint),
-    `${proof.reason}; add a precondition, narrow the return expression, or relax the return contract`
-  );
-}
 export {
   $add,
   $arguments,