nudojs 1.1.0 → 1.2.0

package/dist/index.js

@@ -16209,6 +16209,10 @@ function joinValues(a, b) {
       }
       return makeSum(a, b);
     }
+    const hasPred = (x) => !!x.pred && x.pred.op !== "true";
+    if (hasPred(a) || hasPred(b)) {
+      return makeSum(a, b);
+    }
     return abs(a.shape, void 0, void 0, confJoin(confJoin(a.conf, b.conf), "path"));
   }
   return makeSum(a, b);
@@ -18268,6 +18272,335 @@ var init_invariants = __esm({
   }
 });
 
+// ../core/src/algebra/containers.ts
+function shouldWidenArrayLiteral(n) {
+  return n > TUPLE_LITERAL_CAP;
+}
+function widenedArrayConf() {
+  return "path";
+}
+var TUPLE_LITERAL_CAP, TUPLE_MATERIALIZE_CAP;
+var init_containers = __esm({
+  "../core/src/algebra/containers.ts"() {
+    "use strict";
+    TUPLE_LITERAL_CAP = 8;
+    TUPLE_MATERIALIZE_CAP = 4096;
+  }
+});
+
+// ../core/src/algebra/exec/runtime/state.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+function writeInPlace(target, next) {
+  target.shape = next.shape;
+  target.conf = next.conf;
+  target.term = void 0;
+  target.pred = void 0;
+  return target;
+}
+function clearStaleTermPred(v2) {
+  v2.term = void 0;
+  v2.pred = void 0;
+}
+function currentExecPhi() {
+  return phi;
+}
+function withExecPhi(p, body) {
+  const prev = phi;
+  phi = p;
+  try {
+    return body();
+  } finally {
+    phi = prev;
+  }
+}
+function asAbsVal(v2) {
+  if (v2 && typeof v2 === "object" && "shape" in v2) return v2;
+  if (typeof v2 === "function") {
+    const n = Math.max(0, v2.length);
+    const params = Array.from({ length: n }, (_, i) => `arg${i}`);
+    return absFunction(params, {
+      body: noBody,
+      // 与 $fnVal / $callNamed 同边界：callee 的 NudoReturn 不得冒泡成 caller
+      apply: (args) => callAtFunctionBoundary(() => v2(...args))
+    });
+  }
+  return $lit(v2);
+}
+function callAtFunctionBoundary(body) {
+  let forwarded = [];
+  try {
+    return runWithLoopExits(() => {
+      try {
+        const r = body();
+        forwarded = takeThrowExits();
+        return r;
+      } catch (e) {
+        forwarded = takeThrowExits();
+        if (isNudoReturn(e)) return e.absValue;
+        throw e;
+      }
+    });
+  } finally {
+    for (const x of forwarded) pushThrowExit(x);
+  }
+}
+function $fnVal(params, impl, opts) {
+  return absFunction(params, {
+    body: noBody,
+    // bindThis（对象方法）：receiver 走首参注入，无宿主 this；
+    // 非方法 fn：宿主 this 传递（call/apply/bind 的 thisArg 经 $rawThis 进入函数体）
+    apply: opts?.bindThis ? (args) => callAtFunctionBoundary(() => impl(...args)) : (args, thisVal) => callAtFunctionBoundary(() => impl.apply(thisVal, args)),
+    ...opts?.bindThis ? { bindThis: true } : {}
+  });
+}
+function $rawThis(v2) {
+  if (v2 === void 0 || v2 === globalThis) return $lit(void 0);
+  if (v2 && typeof v2 === "object" && "shape" in v2) return v2;
+  return $lit(v2);
+}
+function throwStrictWrite() {
+  throw new NudoThrow(errorTypeAbs("TypeError"));
+}
+function $throwConstAssign() {
+  throw new NudoThrow(errorTypeAbs("TypeError"));
+}
+function $litTruth(a) {
+  return litTruth(a);
+}
+function $lit(v2) {
+  if (v2 && typeof v2 === "object" && "shape" in v2 && "conf" in v2) {
+    return v2;
+  }
+  return litAbsFromJs(v2);
+}
+function litAbsFromJs(v2, depth = 0) {
+  if (v2 === null || v2 === void 0) {
+    return abs({ k: "unknown" }, { op: "lit", value: v2 }, pTrue, "exact");
+  }
+  const t = typeof v2;
+  if (t === "number" || t === "string" || t === "boolean" || t === "bigint") {
+    return abs(
+      { k: "prim", type: t },
+      { op: "lit", value: v2 },
+      pTrue,
+      "exact"
+    );
+  }
+  if (depth < 8) {
+    if (Array.isArray(v2)) {
+      const els = v2.map((x) => litAbsFromJs(x, depth + 1));
+      if (shouldWidenArrayLiteral(els.length)) {
+        return abs(
+          { k: "arr", element: els.reduce((x, y) => joinAbs(x, y)) },
+          void 0,
+          void 0,
+          widenedArrayConf()
+        );
+      }
+      return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
+    }
+    if (t === "object") {
+      const proto = Object.getPrototypeOf(v2);
+      if (proto === Object.prototype || proto === null) {
+        const slots = {};
+        for (const [k, val] of Object.entries(v2)) {
+          Object.defineProperty(slots, k, {
+            value: { value: litAbsFromJs(val, depth + 1) },
+            enumerable: true,
+            writable: true,
+            configurable: true
+          });
+        }
+        return objOf(slots);
+      }
+    }
+  }
+  return unknown;
+}
+function litTruth(a) {
+  if (a.term?.op === "lit") {
+    return Boolean(a.term.value);
+  }
+  switch (a.shape.k) {
+    case "obj":
+    case "arr":
+    case "tuple":
+    case "fn":
+    case "brand":
+    case "eff":
+      return true;
+    case "prim":
+      return a.shape.type === "symbol" ? true : void 0;
+    case "never":
+      return false;
+    default:
+      return void 0;
+  }
+}
+function isDefinitelyTrue(a) {
+  return litTruth(a) === true;
+}
+function isDefinitelyFalse(a) {
+  const t = litTruth(a);
+  if (t === false) return true;
+  if (a.shape.k === "never") return true;
+  return false;
+}
+function undef() {
+  return abs({ k: "unknown" }, { op: "lit", value: void 0 }, pTrue, "exact");
+}
+function runWithLoopExits(body) {
+  return loopExitsAls.run(
+    [],
+    () => throwExitsAls.run(
+      [],
+      () => tryMarksAls.run([], () => softFrameActiveAls.run([], body))
+    )
+  );
+}
+function takeLoopExits() {
+  return loopExitsAls.getStore() ?? [];
+}
+function takeThrowExits() {
+  return throwExitsAls.getStore() ?? [];
+}
+function pushLoopExit(v2) {
+  loopExitsAls.getStore()?.push(v2);
+}
+function pushThrowExit(v2) {
+  throwExitsAls.getStore()?.push(v2);
+}
+function $pushLoopExit(v2) {
+  pushLoopExit(v2);
+}
+function $tryMark() {
+  $tryMarkSoft();
+  softFrameActiveAls.getStore()?.push(true);
+  const store = throwExitsAls.getStore();
+  const m = store?.length ?? 0;
+  tryMarksAls.getStore()?.push(m);
+  return m;
+}
+function $tryCurrentMark() {
+  const stack = tryMarksAls.getStore();
+  return stack && stack.length > 0 ? stack[stack.length - 1] : 0;
+}
+function $tryPopMark() {
+  tryMarksAls.getStore()?.pop();
+  const soft = softFrameActiveAls.getStore();
+  if (soft && soft.length > 0) {
+    if (soft[soft.length - 1]) $tryReleaseSoftOut();
+    soft.pop();
+  }
+}
+function $tryTakeSince(mark) {
+  const store = throwExitsAls.getStore();
+  if (!store) return [];
+  return store.splice(Math.min(mark, store.length));
+}
+function peekThrowExitsSince(mark) {
+  const store = throwExitsAls.getStore();
+  if (!store) return [];
+  return store.slice(Math.min(mark, store.length));
+}
+function throwExitsMark() {
+  return throwExitsAls.getStore()?.length ?? 0;
+}
+function $tryDigestSoftCatch() {
+  const soft = softFrameActiveAls.getStore();
+  if (!soft || soft.length === 0 || !soft[soft.length - 1]) return;
+  $tryDigestSoft();
+  soft[soft.length - 1] = false;
+}
+function $tryReleaseSoftCatch() {
+  const soft = softFrameActiveAls.getStore();
+  if (!soft || soft.length === 0 || !soft[soft.length - 1]) return;
+  $tryReleaseSoft();
+  soft[soft.length - 1] = false;
+}
+function $tryDetachSoftCatch() {
+  const soft = softFrameActiveAls.getStore();
+  if (!soft || soft.length === 0 || !soft[soft.length - 1]) return [];
+  const effects = popMayThrowFrame(false);
+  soft[soft.length - 1] = false;
+  return effects;
+}
+function $tryDiscardSoft(_effects) {
+}
+function $tryOrphanSoft(effects) {
+  orphanMayThrowEffects(effects);
+}
+function $tryReleaseSoftOut() {
+  const soft = softFrameActiveAls.getStore();
+  if (!soft || soft.length === 0 || !soft[soft.length - 1]) return;
+  $tryReleaseSoft();
+  soft[soft.length - 1] = false;
+}
+function isNudoReturn(e) {
+  return e instanceof NudoReturn;
+}
+function $loopReturn(v2) {
+  throw new NudoReturn(v2);
+}
+function $loopBreak(label) {
+  throw new NudoLoopSignal("break", label || void 0);
+}
+function $loopContinue(label) {
+  throw new NudoLoopSignal("continue", label || void 0);
+}
+function loopSignalMatches(e, label) {
+  return e.label === void 0 || e.label === label;
+}
+function isNudoBreak(e, label) {
+  return e instanceof NudoLoopSignal && e.kind === "break" && loopSignalMatches(e, label);
+}
+function isNudoContinue(e, label) {
+  return e instanceof NudoLoopSignal && e.kind === "continue" && loopSignalMatches(e, label);
+}
+function $isBreakTo(e, label) {
+  return e instanceof NudoLoopSignal && e.kind === "break" && e.label === label;
+}
+function $rethrowIfNudoReturn(e) {
+  if (isNudoReturn(e)) throw e;
+}
+var phi, noBody, loopExitsAls, throwExitsAls, tryMarksAls, softFrameActiveAls, NudoReturn, NudoLoopSignal;
+var init_state = __esm({
+  "../core/src/algebra/exec/runtime/state.ts"() {
+    "use strict";
+    init_abs();
+    init_pred();
+    init_abs_fn();
+    init_nudo_throw();
+    init_may_throw();
+    init_containers();
+    init_objects();
+    phi = pTrue;
+    noBody = { type: "BlockStatement", body: [], directives: [] };
+    loopExitsAls = new AsyncLocalStorage2();
+    throwExitsAls = new AsyncLocalStorage2();
+    tryMarksAls = new AsyncLocalStorage2();
+    softFrameActiveAls = new AsyncLocalStorage2();
+    NudoReturn = class extends Error {
+      absValue;
+      constructor(absValue) {
+        super("nudo:return");
+        this.name = "NudoReturn";
+        this.absValue = absValue;
+      }
+    };
+    NudoLoopSignal = class extends Error {
+      kind;
+      label;
+      constructor(kind, label) {
+        super("nudo:loop");
+        this.name = "NudoLoopSignal";
+        this.kind = kind;
+        this.label = label;
+      }
+    };
+  }
+});
+
 // ../core/src/algebra/builtins/shared.ts
 function numPrim(conf = "path") {
   return abs({ k: "prim", type: "number" }, void 0, void 0, conf);
@@ -18291,12 +18624,12 @@ function isPrimLike(a) {
   }
   return false;
 }
-var noBody;
+var noBody2;
 var init_shared = __esm({
   "../core/src/algebra/builtins/shared.ts"() {
     "use strict";
     init_abs();
-    noBody = { type: "BlockStatement", body: [], directives: [] };
+    noBody2 = { type: "BlockStatement", body: [], directives: [] };
   }
 });
 
@@ -18316,8 +18649,194 @@ function mathMethod(name) {
   const impl = Math[name];
   return typeof impl === "function" ? impl : void 0;
 }
+function isNonNaN(a, phi2) {
+  if (a.term?.op === "lit") {
+    return typeof a.term.value === "number" && !Number.isNaN(a.term.value);
+  }
+  const hasNonNaNFact = (p) => {
+    if (!p) return false;
+    if (p.op === "and") return p.args.some(hasNonNaNFact);
+    if (p.op === "assumeFinite") {
+      return !!a.term && termEquals(p.t, a.term);
+    }
+    if (p.op === "ne") {
+      if (p.b.op === "lit" && typeof p.b.value === "number" && Number.isNaN(p.b.value) && a.term && termEquals(p.a, a.term)) {
+        return true;
+      }
+    }
+    if (p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") {
+      if (a.term && (termEquals(p.a, a.term) || termEquals(p.b, a.term))) return true;
+    }
+    return false;
+  };
+  if (hasNonNaNFact(a.pred)) return true;
+  if (a.term?.op === "var") {
+    const id = a.term.id;
+    const conjs = phi2.op === "and" ? phi2.args : [phi2];
+    for (const p of conjs) {
+      if (p.op === "assumeFinite" && p.t.op === "var" && p.t.id === id) {
+        return true;
+      }
+      if (p.op === "ne") {
+        const b = p.b;
+        if (b.op === "lit" && typeof b.value === "number" && Number.isNaN(b.value) && p.a.op === "var" && p.a.id === id) {
+          return true;
+        }
+      }
+      if (p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") {
+        const sides = [p.a, p.b];
+        if (sides.some((t) => t.op === "var" && t.id === id) && sides.some((t) => t.op === "lit" && typeof t.value === "number")) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function ieeeBoundNum(n) {
+  return Number.isFinite(n) || n === Infinity || n === -Infinity ? n : void 0;
+}
+function loMin(a, b) {
+  if (a.lo === void 0 || b.lo === void 0) return void 0;
+  if (b.lo.value < a.lo.value) return b.lo;
+  if (b.lo.value === a.lo.value && b.lo.strict && !a.lo.strict) return b.lo;
+  return a.lo;
+}
+function loMax(a, b) {
+  if (a.lo === void 0) return b.lo;
+  if (b.lo === void 0) return a.lo;
+  if (b.lo.value > a.lo.value) return b.lo;
+  if (b.lo.value === a.lo.value && b.lo.strict && !a.lo.strict) return b.lo;
+  return a.lo;
+}
+function hiMin(a, b) {
+  if (a.hi === void 0) return b.hi;
+  if (b.hi === void 0) return a.hi;
+  if (b.hi.value < a.hi.value) return b.hi;
+  if (b.hi.value === a.hi.value && b.hi.strict && !a.hi.strict) return b.hi;
+  return a.hi;
+}
+function hiMax(a, b) {
+  if (a.hi === void 0 || b.hi === void 0) return void 0;
+  if (b.hi.value > a.hi.value) return b.hi;
+  if (b.hi.value === a.hi.value && b.hi.strict && !a.hi.strict) return b.hi;
+  return a.hi;
+}
+function boundsToPred(t, b) {
+  const facts = [];
+  if (b.lo !== void 0) {
+    const v2 = ieeeBoundNum(b.lo.value);
+    if (v2 !== void 0) {
+      facts.push(b.lo.strict ? { op: "gt", a: t, b: lit(v2) } : { op: "ge", a: t, b: lit(v2) });
+    }
+  }
+  if (b.hi !== void 0) {
+    const v2 = ieeeBoundNum(b.hi.value);
+    if (v2 !== void 0) {
+      facts.push(b.hi.strict ? { op: "lt", a: t, b: lit(v2) } : { op: "le", a: t, b: lit(v2) });
+    }
+  }
+  if (facts.length === 0) return void 0;
+  return facts.length === 1 ? facts[0] : and(...facts);
+}
+function minMaxAbs(name, args) {
+  const phi2 = currentExecPhi();
+  const empty = {};
+  let acc = empty;
+  const termArgs = args.map(
+    (a, i) => a.term ?? app(`arg${i}`, [])
+  );
+  const term = simplifyTerm(app(`Math.${name}`, termArgs));
+  let first = true;
+  let mayNaN = false;
+  for (const a of args) {
+    if (!isNonNaN(a, phi2)) mayNaN = true;
+    const b = numericBounds(a, phi2) ?? {};
+    if (first) {
+      acc = { lo: b.lo, hi: b.hi };
+      first = false;
+      continue;
+    }
+    if (name === "min") {
+      acc = { lo: loMin(acc, b), hi: hiMin(acc, b) };
+    } else {
+      acc = { lo: loMax(acc, b), hi: hiMax(acc, b) };
+    }
+  }
+  const pred = boundsToPred(term, acc);
+  const bounded = abs({ k: "prim", type: "number" }, term, pred, "path");
+  if (!mayNaN) return bounded;
+  const nanArm = numLit(NaN);
+  return makeSum(nanArm, bounded);
+}
+function roundingAbs(name, arg) {
+  const phi2 = currentExecPhi();
+  const impl = name === "round" ? Math.round : name === "floor" ? Math.floor : name === "ceil" ? Math.ceil : Math.trunc;
+  const b = numericBounds(arg, phi2);
+  const mayNaN = !isNonNaN(arg, phi2);
+  const term = arg.term ? simplifyTerm(app(`Math.${name}`, [arg.term])) : void 0;
+  let out = {};
+  if (b) {
+    if (b.lo !== void 0) {
+      const v2 = impl(b.lo.value);
+      out.lo = Number.isNaN(v2) ? void 0 : { value: v2, strict: false };
+    }
+    if (b.hi !== void 0) {
+      const v2 = impl(b.hi.value);
+      out.hi = Number.isNaN(v2) ? void 0 : { value: v2, strict: false };
+    }
+  }
+  const pred = term ? boundsToPred(term, out) : void 0;
+  const bounded = abs({ k: "prim", type: "number" }, term, pred, "path");
+  if (!mayNaN) return bounded;
+  return makeSum(numLit(NaN), bounded);
+}
 function evalMathMethod(name, args) {
   if (name === "random") return numPrim("path");
+  if (name === "min" || name === "max") {
+    const nums2 = [];
+    let allLit = true;
+    for (const a of args) {
+      const n = coerceMathArg(a);
+      if (n === void 0) {
+        allLit = false;
+        break;
+      }
+      if (n === "throw") throw new NudoThrow(errorTypeAbs("TypeError"));
+      nums2.push(n);
+    }
+    if (allLit) {
+      try {
+        return numLit((name === "min" ? Math.min : Math.max)(...nums2));
+      } catch {
+        return numPrim();
+      }
+    }
+    for (const a of args) {
+      const n = coerceMathArg(a);
+      if (n === "throw") throw new NudoThrow(errorTypeAbs("TypeError"));
+    }
+    return minMaxAbs(name, args);
+  }
+  if (name === "round" || name === "floor" || name === "ceil" || name === "trunc") {
+    const n = coerceMathArg(args[0]);
+    if (n === "throw") throw new NudoThrow(errorTypeAbs("TypeError"));
+    if (typeof n === "number") {
+      try {
+        return numLit(
+          name === "round" ? Math.round(n) : name === "floor" ? Math.floor(n) : name === "ceil" ? Math.ceil(n) : Math.trunc(n)
+        );
+      } catch {
+        return numPrim();
+      }
+    }
+    if (args[0]) {
+      const c2 = coerceMathArg(args[0]);
+      if (c2 === "throw") throw new NudoThrow(errorTypeAbs("TypeError"));
+      return roundingAbs(name, args[0]);
+    }
+    return numPrim();
+  }
   const impl = mathMethod(name);
   if (!impl) return void 0;
   const nums = [];
@@ -18337,28 +18856,17 @@ var init_math = __esm({
   "../core/src/algebra/builtins/math.ts"() {
     "use strict";
     init_abs();
+    init_term();
+    init_pred();
+    init_arithmetic();
+    init_objects();
+    init_state();
     init_shared();
     init_nudo_throw();
     init_may_throw();
   }
 });
 
-// ../core/src/algebra/containers.ts
-function shouldWidenArrayLiteral(n) {
-  return n > TUPLE_LITERAL_CAP;
-}
-function widenedArrayConf() {
-  return "path";
-}
-var TUPLE_LITERAL_CAP, TUPLE_MATERIALIZE_CAP;
-var init_containers = __esm({
-  "../core/src/algebra/containers.ts"() {
-    "use strict";
-    TUPLE_LITERAL_CAP = 8;
-    TUPLE_MATERIALIZE_CAP = 4096;
-  }
-});
-
 // ../core/src/algebra/builtins/ctor.ts
 function builtinCtorAbs(name) {
   let a = builtinCtorByName.get(name);
@@ -19130,8 +19638,19 @@ function evalNumberStatic(name, args) {
   switch (name) {
     case "isInteger":
       return foldStrictNumberPred(Number.isInteger) ?? boolPrim();
-    case "isNaN":
-      return foldStrictNumberPred(Number.isNaN) ?? boolPrim();
+    case "isNaN": {
+      const folded = foldStrictNumberPred(Number.isNaN);
+      if (folded) return folded;
+      if (a0Arg?.term) {
+        return abs(
+          { k: "prim", type: "boolean" },
+          void 0,
+          { op: "eq", a: a0Arg.term, b: { op: "lit", value: NaN } },
+          "path"
+        );
+      }
+      return boolPrim();
+    }
     case "isFinite":
       return foldStrictNumberPred(Number.isFinite) ?? boolPrim();
     case "parseInt": {
@@ -20036,7 +20555,7 @@ function arrayJoinToString(recv) {
 }
 function arrayMethodAbs(name) {
   return absFunction(["thisArg"], {
-    body: noBody,
+    body: noBody2,
     bindThis: true,
     apply: (a) => {
       const recv = a[0] ?? undefAbs();
@@ -20452,11 +20971,11 @@ function evalPromiseCtor(args) {
     return undefAbs();
   };
   const resolveAbs = absFunction(["value"], {
-    body: noBody,
+    body: noBody2,
     apply: (args2) => onResolve(args2[0])
   });
   const rejectAbs = absFunction(["reason"], {
-    body: noBody,
+    body: noBody2,
     apply: (args2) => onReject(args2[0])
   });
   enterPromiseExecutorScope();
@@ -21193,7 +21712,7 @@ function evalObjectProtoMethod(name, thisVal, args) {
 }
 function objectProtoMethodAbs(name) {
   return absFunction(["thisArg", "arg0"], {
-    body: noBody,
+    body: noBody2,
     bindThis: true,
     apply: (a) => {
       const recv = a[0] ?? undefLit();
@@ -28294,319 +28813,6 @@ var init_transpile = __esm({
   }
 });
 
-// ../core/src/algebra/exec/runtime/state.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-function writeInPlace(target, next) {
-  target.shape = next.shape;
-  target.conf = next.conf;
-  target.term = void 0;
-  target.pred = void 0;
-  return target;
-}
-function clearStaleTermPred(v2) {
-  v2.term = void 0;
-  v2.pred = void 0;
-}
-function currentExecPhi() {
-  return phi;
-}
-function withExecPhi(p, body) {
-  const prev = phi;
-  phi = p;
-  try {
-    return body();
-  } finally {
-    phi = prev;
-  }
-}
-function asAbsVal(v2) {
-  if (v2 && typeof v2 === "object" && "shape" in v2) return v2;
-  if (typeof v2 === "function") {
-    const n = Math.max(0, v2.length);
-    const params = Array.from({ length: n }, (_, i) => `arg${i}`);
-    return absFunction(params, {
-      body: noBody2,
-      // 与 $fnVal / $callNamed 同边界：callee 的 NudoReturn 不得冒泡成 caller
-      apply: (args) => callAtFunctionBoundary(() => v2(...args))
-    });
-  }
-  return $lit(v2);
-}
-function callAtFunctionBoundary(body) {
-  let forwarded = [];
-  try {
-    return runWithLoopExits(() => {
-      try {
-        const r = body();
-        forwarded = takeThrowExits();
-        return r;
-      } catch (e) {
-        forwarded = takeThrowExits();
-        if (isNudoReturn(e)) return e.absValue;
-        throw e;
-      }
-    });
-  } finally {
-    for (const x of forwarded) pushThrowExit(x);
-  }
-}
-function $fnVal(params, impl, opts) {
-  return absFunction(params, {
-    body: noBody2,
-    // bindThis（对象方法）：receiver 走首参注入，无宿主 this；
-    // 非方法 fn：宿主 this 传递（call/apply/bind 的 thisArg 经 $rawThis 进入函数体）
-    apply: opts?.bindThis ? (args) => callAtFunctionBoundary(() => impl(...args)) : (args, thisVal) => callAtFunctionBoundary(() => impl.apply(thisVal, args)),
-    ...opts?.bindThis ? { bindThis: true } : {}
-  });
-}
-function $rawThis(v2) {
-  if (v2 === void 0 || v2 === globalThis) return $lit(void 0);
-  if (v2 && typeof v2 === "object" && "shape" in v2) return v2;
-  return $lit(v2);
-}
-function throwStrictWrite() {
-  throw new NudoThrow(errorTypeAbs("TypeError"));
-}
-function $throwConstAssign() {
-  throw new NudoThrow(errorTypeAbs("TypeError"));
-}
-function $litTruth(a) {
-  return litTruth(a);
-}
-function $lit(v2) {
-  if (v2 && typeof v2 === "object" && "shape" in v2 && "conf" in v2) {
-    return v2;
-  }
-  return litAbsFromJs(v2);
-}
-function litAbsFromJs(v2, depth = 0) {
-  if (v2 === null || v2 === void 0) {
-    return abs({ k: "unknown" }, { op: "lit", value: v2 }, pTrue, "exact");
-  }
-  const t = typeof v2;
-  if (t === "number" || t === "string" || t === "boolean" || t === "bigint") {
-    return abs(
-      { k: "prim", type: t },
-      { op: "lit", value: v2 },
-      pTrue,
-      "exact"
-    );
-  }
-  if (depth < 8) {
-    if (Array.isArray(v2)) {
-      const els = v2.map((x) => litAbsFromJs(x, depth + 1));
-      if (shouldWidenArrayLiteral(els.length)) {
-        return abs(
-          { k: "arr", element: els.reduce((x, y) => joinAbs(x, y)) },
-          void 0,
-          void 0,
-          widenedArrayConf()
-        );
-      }
-      return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
-    }
-    if (t === "object") {
-      const proto = Object.getPrototypeOf(v2);
-      if (proto === Object.prototype || proto === null) {
-        const slots = {};
-        for (const [k, val] of Object.entries(v2)) {
-          Object.defineProperty(slots, k, {
-            value: { value: litAbsFromJs(val, depth + 1) },
-            enumerable: true,
-            writable: true,
-            configurable: true
-          });
-        }
-        return objOf(slots);
-      }
-    }
-  }
-  return unknown;
-}
-function litTruth(a) {
-  if (a.term?.op === "lit") {
-    return Boolean(a.term.value);
-  }
-  switch (a.shape.k) {
-    case "obj":
-    case "arr":
-    case "tuple":
-    case "fn":
-    case "brand":
-    case "eff":
-      return true;
-    case "prim":
-      return a.shape.type === "symbol" ? true : void 0;
-    case "never":
-      return false;
-    default:
-      return void 0;
-  }
-}
-function isDefinitelyTrue(a) {
-  return litTruth(a) === true;
-}
-function isDefinitelyFalse(a) {
-  const t = litTruth(a);
-  if (t === false) return true;
-  if (a.shape.k === "never") return true;
-  return false;
-}
-function undef() {
-  return abs({ k: "unknown" }, { op: "lit", value: void 0 }, pTrue, "exact");
-}
-function runWithLoopExits(body) {
-  return loopExitsAls.run(
-    [],
-    () => throwExitsAls.run(
-      [],
-      () => tryMarksAls.run([], () => softFrameActiveAls.run([], body))
-    )
-  );
-}
-function takeLoopExits() {
-  return loopExitsAls.getStore() ?? [];
-}
-function takeThrowExits() {
-  return throwExitsAls.getStore() ?? [];
-}
-function pushLoopExit(v2) {
-  loopExitsAls.getStore()?.push(v2);
-}
-function pushThrowExit(v2) {
-  throwExitsAls.getStore()?.push(v2);
-}
-function $pushLoopExit(v2) {
-  pushLoopExit(v2);
-}
-function $tryMark() {
-  $tryMarkSoft();
-  softFrameActiveAls.getStore()?.push(true);
-  const store = throwExitsAls.getStore();
-  const m = store?.length ?? 0;
-  tryMarksAls.getStore()?.push(m);
-  return m;
-}
-function $tryCurrentMark() {
-  const stack = tryMarksAls.getStore();
-  return stack && stack.length > 0 ? stack[stack.length - 1] : 0;
-}
-function $tryPopMark() {
-  tryMarksAls.getStore()?.pop();
-  const soft = softFrameActiveAls.getStore();
-  if (soft && soft.length > 0) {
-    if (soft[soft.length - 1]) $tryReleaseSoftOut();
-    soft.pop();
-  }
-}
-function $tryTakeSince(mark) {
-  const store = throwExitsAls.getStore();
-  if (!store) return [];
-  return store.splice(Math.min(mark, store.length));
-}
-function peekThrowExitsSince(mark) {
-  const store = throwExitsAls.getStore();
-  if (!store) return [];
-  return store.slice(Math.min(mark, store.length));
-}
-function throwExitsMark() {
-  return throwExitsAls.getStore()?.length ?? 0;
-}
-function $tryDigestSoftCatch() {
-  const soft = softFrameActiveAls.getStore();
-  if (!soft || soft.length === 0 || !soft[soft.length - 1]) return;
-  $tryDigestSoft();
-  soft[soft.length - 1] = false;
-}
-function $tryReleaseSoftCatch() {
-  const soft = softFrameActiveAls.getStore();
-  if (!soft || soft.length === 0 || !soft[soft.length - 1]) return;
-  $tryReleaseSoft();
-  soft[soft.length - 1] = false;
-}
-function $tryDetachSoftCatch() {
-  const soft = softFrameActiveAls.getStore();
-  if (!soft || soft.length === 0 || !soft[soft.length - 1]) return [];
-  const effects = popMayThrowFrame(false);
-  soft[soft.length - 1] = false;
-  return effects;
-}
-function $tryDiscardSoft(_effects) {
-}
-function $tryOrphanSoft(effects) {
-  orphanMayThrowEffects(effects);
-}
-function $tryReleaseSoftOut() {
-  const soft = softFrameActiveAls.getStore();
-  if (!soft || soft.length === 0 || !soft[soft.length - 1]) return;
-  $tryReleaseSoft();
-  soft[soft.length - 1] = false;
-}
-function isNudoReturn(e) {
-  return e instanceof NudoReturn;
-}
-function $loopReturn(v2) {
-  throw new NudoReturn(v2);
-}
-function $loopBreak(label) {
-  throw new NudoLoopSignal("break", label || void 0);
-}
-function $loopContinue(label) {
-  throw new NudoLoopSignal("continue", label || void 0);
-}
-function loopSignalMatches(e, label) {
-  return e.label === void 0 || e.label === label;
-}
-function isNudoBreak(e, label) {
-  return e instanceof NudoLoopSignal && e.kind === "break" && loopSignalMatches(e, label);
-}
-function isNudoContinue(e, label) {
-  return e instanceof NudoLoopSignal && e.kind === "continue" && loopSignalMatches(e, label);
-}
-function $isBreakTo(e, label) {
-  return e instanceof NudoLoopSignal && e.kind === "break" && e.label === label;
-}
-function $rethrowIfNudoReturn(e) {
-  if (isNudoReturn(e)) throw e;
-}
-var phi, noBody2, loopExitsAls, throwExitsAls, tryMarksAls, softFrameActiveAls, NudoReturn, NudoLoopSignal;
-var init_state = __esm({
-  "../core/src/algebra/exec/runtime/state.ts"() {
-    "use strict";
-    init_abs();
-    init_pred();
-    init_abs_fn();
-    init_nudo_throw();
-    init_may_throw();
-    init_containers();
-    init_objects();
-    phi = pTrue;
-    noBody2 = { type: "BlockStatement", body: [], directives: [] };
-    loopExitsAls = new AsyncLocalStorage2();
-    throwExitsAls = new AsyncLocalStorage2();
-    tryMarksAls = new AsyncLocalStorage2();
-    softFrameActiveAls = new AsyncLocalStorage2();
-    NudoReturn = class extends Error {
-      absValue;
-      constructor(absValue) {
-        super("nudo:return");
-        this.name = "NudoReturn";
-        this.absValue = absValue;
-      }
-    };
-    NudoLoopSignal = class extends Error {
-      kind;
-      label;
-      constructor(kind, label) {
-        super("nudo:loop");
-        this.name = "NudoLoopSignal";
-        this.kind = kind;
-        this.label = label;
-      }
-    };
-  }
-});
-
 // ../core/src/algebra/exec/runtime/ops.ts
 function $unknown() {
   return abs({ k: "unknown" }, void 0, void 0, "opaque");
@@ -29173,7 +29379,7 @@ function $instanceofNonIdent(_left) {
 }
 function $classExpr() {
   return absFunction(["_rest"], {
-    body: noBody2,
+    body: noBody,
     apply: () => unknown
   });
 }
@@ -30100,7 +30306,7 @@ function $get(o, key, opts) {
         const raw = o[key];
         if (typeof raw === "function") {
           return absFunction([`${ns}.${key}`], {
-            body: noBody2,
+            body: noBody,
             apply: (args) => evalNamespaceCall(ns, key, args) ?? unknown
           });
         }
@@ -30119,7 +30325,7 @@ function $get(o, key, opts) {
   }
   if (o.shape.k === "eff" && o.shape.eff === "promise" && (key === "then" || key === "catch" || key === "finally")) {
     return absFunction([key === "then" ? "onFulfilled" : key === "catch" ? "onRejected" : "onFinally"], {
-      body: noBody2
+      body: noBody
     });
   }
   if (o.shape.k === "brand") {
@@ -30130,7 +30336,7 @@ function $get(o, key, opts) {
     const isClassVal = classNameOfValue(o) === o.shape.name;
     const builtinM = BUILTIN_BRAND_METHODS[o.shape.name];
     if (builtinM && !isClassVal && (key === "@@iterator" || builtinM.has(key))) {
-      return absFunction([], { body: noBody2 });
+      return absFunction([], { body: noBody });
     }
     if (key === "size" && o.shape.name === "Map") return mapSizeAbs(o);
     if (key === "size" && o.shape.name === "Set") return setSizeAbs(o);
@@ -30146,14 +30352,14 @@ function $get(o, key, opts) {
       for (const n of evalClassChain(o.shape.name)) {
         const spec = getEvalClass(n);
         if (spec?.staticMethods?.[key]) {
-          return absFunction(spec.staticMethodParams?.[key] ?? [], { body: noBody2 });
+          return absFunction(spec.staticMethodParams?.[key] ?? [], { body: noBody });
         }
       }
       if (key === "prototype") {
         return abs({ k: "obj", slots: {} }, void 0, void 0, "path");
       }
       if (key === "call" || key === "apply" || key === "bind") {
-        return absFunction([], { body: noBody2 });
+        return absFunction([], { body: noBody });
       }
     } else {
       const acc = findClassAccessor(o.shape.name, key);
@@ -30162,7 +30368,7 @@ function $get(o, key, opts) {
       for (const n of evalClassChain(o.shape.name)) {
         const spec = getEvalClass(n);
         if (spec?.methods?.[key]) {
-          return absFunction(spec.methodParams?.[key] ?? [], { body: noBody2 });
+          return absFunction(spec.methodParams?.[key] ?? [], { body: noBody });
         }
       }
     }
@@ -36268,60 +36474,92 @@ function isBoundedEvidenceMissing(ret, constraint) {
   if (ret.pred && ret.pred.op !== "true") return false;
   return true;
 }
+function flattenSumArms(ret) {
+  if (ret.shape.k !== "sum") return [ret];
+  const out = [];
+  for (const m of ret.shape.members) {
+    if (m.shape.k === "sum") out.push(...flattenSumArms(m));
+    else out.push(m);
+  }
+  return out;
+}
+function isWidenedSumArm(m, parent) {
+  return parent.conf === "partial" && m.shape.k === "prim" && !m.term && (!m.pred || m.pred.op === "true");
+}
 function assertImplies(ret, constraint, opts) {
   const phi2 = opts?.phi ?? pTrue;
   if (ret.shape.k === "never") return proved();
   if (isAnyConstraint(constraint)) return proved();
-  const nullishOk = constraintAdmitsNullish(constraint);
-  if (isNullishLitAbs(ret)) {
-    return nullishOk ? proved() : disproved(`nullish return \u22AD ${formatConstraint(constraint)}`);
-  }
-  let sumMembers;
-  if (ret.shape.k === "sum") {
-    const members = ret.shape.members;
-    const nullishMembers = members.filter((m) => isNullishLitAbs(m));
-    if (nullishMembers.length > 0 && !nullishOk) {
-      return disproved(
-        `nullish return arm \u22AD ${formatConstraint(constraint)} (contract does not admit nullish)`
-      );
-    }
-    sumMembers = members.filter((m) => !isNullishLitAbs(m));
-  }
   if (isValueSetUnknown(ret)) {
     return unprovable(
       ret.shape.k === "any" ? "any does not establish the return contract" : "inference failure (unknown/opaque) \u2014 cannot prove the return contract"
     );
   }
+  const arms = flattenSumArms(ret);
+  if (arms.length > 1) {
+    return assertSumArms(arms, ret, constraint, opts, phi2);
+  }
+  return assertImpliesSingle(arms[0], constraint, opts, phi2);
+}
+function assertSumArms(arms, parent, constraint, opts, phi2) {
+  const hasWidenedArm = arms.some(
+    (a) => isValueSetUnknown(a) || isWidenedSumArm(a, parent)
+  );
+  let sawUnprovable = false;
+  for (const arm of arms) {
+    if (isNullishLitAbs(arm)) {
+      if (!constraintAdmitsNullish(constraint)) {
+        return disproved(
+          `nullish return arm \u22AD ${formatConstraint(constraint)} (contract does not admit nullish)`
+        );
+      }
+      continue;
+    }
+    if (isValueSetUnknown(arm) || isWidenedSumArm(arm, parent)) {
+      sawUnprovable = true;
+      continue;
+    }
+    const r = assertImpliesSingle(arm, constraint, opts, phi2);
+    if (r.status === "disproved") {
+      if (hasWidenedArm) {
+        sawUnprovable = true;
+        continue;
+      }
+      return r;
+    }
+    if (r.status === "unprovable") sawUnprovable = true;
+  }
+  return sawUnprovable ? unprovable("sum: some arms unprovable") : proved();
+}
+function assertImpliesSingle(arm, constraint, opts, phi2) {
+  if (isNullishLitAbs(arm)) {
+    return constraintAdmitsNullish(constraint) ? proved() : disproved(`nullish return \u22AD ${formatConstraint(constraint)}`);
+  }
+  if (isValueSetUnknown(arm)) {
+    return unprovable(
+      arm.shape.k === "any" ? "any does not establish the return contract" : "inference failure (unknown/opaque) \u2014 cannot prove the return contract"
+    );
+  }
   if (constraint.members && constraint.members.length > 0) {
     let sawUnprovable = false;
     for (const m of constraint.members) {
-      const r = assertImplies(ret, m, opts);
+      const r = assertImplies(arm, m, opts);
       if (r.status === "proved") return proved();
       if (r.status === "unprovable") sawUnprovable = true;
     }
     return sawUnprovable ? unprovable("union: no member proved the return contract") : disproved(`return \u22AD union(${constraint.members.map((m) => formatConstraint(m)).join(", ")})`);
   }
-  if (sumMembers && (constraint.fields || constraint.element)) {
-    let sawUnprovable = false;
-    for (const m of sumMembers) {
-      if (isValueSetUnknown(m)) continue;
-      const r = assertImplies(m, constraint, opts);
-      if (r.status === "disproved") return r;
-      if (r.status === "unprovable") sawUnprovable = true;
-    }
-    return sawUnprovable ? unprovable("sum: some arms unprovable") : proved();
-  }
   if (constraint.fields) {
-    return assertShapeFields(ret, constraint, opts);
+    return assertShapeFields(arm, constraint, opts);
   }
   if (constraint.element) {
-    if (ret.shape.k !== "arr" && ret.shape.k !== "tuple") {
-      return disproved(`return shape ${ret.shape.k} \u22AD array(...)`);
+    if (arm.shape.k !== "arr" && arm.shape.k !== "tuple") {
+      return disproved(`return shape ${arm.shape.k} \u22AD array(...)`);
     }
     return proved();
   }
   if (constraint.fn) return proved();
-  return assertScalar(ret, constraint, phi2);
+  return assertScalar(arm, constraint, phi2);
 }
 function isAnyConstraint(c) {
   return !c.prim && c.preds.length === 0 && !c.fields && !c.element && !c.members && !c.fn && !isIntFlag(c);
@@ -39360,7 +39598,7 @@ function checkSourceInner(filePath, source, file, phi2, opts, issues, signatures
             message: `${name} (export): may throw ${gateDisplay}`,
             actual: `${name}(\u2026)    throws ${gateDisplay}`,
             expected: "entry total, or @nudo:throws / try-catch",
-            suggestion: first.cause ? `${first.cause} \u2192 ${first.kind === "ReferenceError" ? "re-export `export { x } from` \u4E0D\u662F\u5C40\u90E8\u7ED1\u5B9A\u2014\u2014\u6539 `import { x }` / @nudo:throws ReferenceError" : `@nudo:throws ${first.kind} / sidecar fn({ \u2026 }) contract / refine / guard / try-catch`}` : first.kind === "ReferenceError" ? "re-export `export { x } from` \u4E0D\u662F\u5C40\u90E8\u7ED1\u5B9A\u2014\u2014\u6539 `import { x }` / @nudo:throws ReferenceError" : `@nudo:throws ${first.kind} / sidecar fn({ \u2026 }) contract / refine / guard / try-catch`,
+            suggestion: first.cause ? `${first.cause} \u2192 ${first.kind === "ReferenceError" ? "re-export `export { x } from` \u4E0D\u662F\u5C40\u90E8\u7ED1\u5B9A\u2014\u2014\u6539 `import { x }` / @nudo:throws ReferenceError" : `@nudo:throws ${first.kind}  |  sidecar: fn({ \u2026 }): shape({ <body-read fields> })  |  refine / guard / try-catch`}` : first.kind === "ReferenceError" ? "re-export `export { x } from` \u4E0D\u662F\u5C40\u90E8\u7ED1\u5B9A\u2014\u2014\u6539 `import { x }` / @nudo:throws ReferenceError" : `@nudo:throws ${first.kind}  |  sidecar: fn({ \u2026 }): shape({ <body-read fields> })  |  refine / guard / try-catch`,
             fn: name,
             ...loc.line !== void 0 ? { line: loc.line } : {},
             ...loc.column !== void 0 ? { column: loc.column } : {}
@@ -39405,7 +39643,7 @@ function checkSourceInner(filePath, source, file, phi2, opts, issues, signatures
           message: `${name} (export): may throw ${gateDisplay}`,
           actual: `${formatEntrySigLine(name, g, gateDisplay)}`,
           expected: "entry total, or @nudo:throws / try-catch",
-          suggestion: first.cause ? `${first.cause} \u2192 ${first.kind === "ReferenceError" ? "re-export `export { x } from` \u4E0D\u662F\u5C40\u90E8\u7ED1\u5B9A\u2014\u2014\u6539 `import { x }` / @nudo:throws ReferenceError" : `@nudo:throws ${first.kind} / sidecar fn({ \u2026 }) contract / refine / guard / try-catch`}` : first.kind === "ReferenceError" ? "re-export `export { x } from` \u4E0D\u662F\u5C40\u90E8\u7ED1\u5B9A\u2014\u2014\u6539 `import { x }` / @nudo:throws ReferenceError" : `@nudo:throws ${first.kind} / sidecar fn({ \u2026 }) contract / refine / guard / try-catch`,
+          suggestion: first.cause ? `${first.cause} \u2192 ${first.kind === "ReferenceError" ? "re-export `export { x } from` \u4E0D\u662F\u5C40\u90E8\u7ED1\u5B9A\u2014\u2014\u6539 `import { x }` / @nudo:throws ReferenceError" : `@nudo:throws ${first.kind}  |  sidecar: fn({ \u2026 }): shape({ <body-read fields> })  |  refine / guard / try-catch`}` : first.kind === "ReferenceError" ? "re-export `export { x } from` \u4E0D\u662F\u5C40\u90E8\u7ED1\u5B9A\u2014\u2014\u6539 `import { x }` / @nudo:throws ReferenceError" : `@nudo:throws ${first.kind}  |  sidecar: fn({ \u2026 }): shape({ <body-read fields> })  |  refine / guard / try-catch`,
           fn: name,
           ...loc.line !== void 0 ? { line: loc.line } : {},
           ...loc.column !== void 0 ? { column: loc.column } : {}
@@ -39805,6 +40043,19 @@ function actionsForIssue(i) {
           label: "migration switch: ignore this throw class on L2"
         }
       ];
+    case "nudo:unproven-return":
+      return [
+        {
+          kind: "relax",
+          label: `relax the return contract${i.fn ? ` of ${i.fn}` : ""} to the inferred surface (review the diff \u2014 not a silent green)`,
+          ...i.expected ? { hint: i.expected } : {}
+        },
+        draft,
+        {
+          kind: "info",
+          label: "or narrow the return expression / add a precondition so the bound is implied"
+        }
+      ];
     case "nudo:unknown-inference":
     case "nudo:opaque-result":
       return [
@@ -277240,14 +277491,20 @@ __export(emit_exports, {
   absToStandardSchemaModule: () => absToStandardSchemaModule,
   absToTSType: () => absToTSType,
   absToZodSchemaModule: () => absToZodSchemaModule,
+  addBudgetAnnotation: () => addBudgetAnnotation,
+  addThrowsAnnotation: () => addThrowsAnnotation,
+  applyTextEdits: () => applyTextEdits,
+  bodyReadFieldsFor: () => bodyReadFieldsFor,
   buildCaseDirective: () => buildCaseDirective,
   collectParamBodyAccesses: () => collectParamBodyAccesses,
+  collectParamBodyReadTypes: () => collectParamBodyReadTypes,
   constraintToSchemaNode: () => constraintToSchemaNode,
   deriveFromRoot: () => deriveFromRoot,
   draftInterface: () => draftInterface,
   emitDerivedFromRoot: () => emitDerivedFromRoot,
   emitInterface: () => emitInterface,
   extractFnConstraintSources: () => extractFnConstraintSources,
+  findFnDeclStart: () => findFnDeclStart,
   formatDerivedSection: () => formatDerivedSection,
   formatDraftModule: () => formatDraftModule,
   formatDraftSummary: () => formatDraftSummary,
@@ -277261,15 +277518,19 @@ __export(emit_exports, {
   insertGeneratedCaseDirectives: () => insertGeneratedCaseDirectives,
   interfaceSurface: () => interfaceSurface,
   isDraftableEntry: () => isDraftableEntry,
+  materializeAction: () => materializeAction,
   projectAbsToSchema: () => projectAbsToSchema,
   schemaNodeToZod: () => schemaNodeToZod,
   serializeCaseArg: () => serializeCaseArg,
   serializeCaseJson: () => serializeCaseJson,
+  shapeDslFromFields: () => shapeDslFromFields,
   sidecarDraftPath: () => sidecarDraftPath,
   stripGeneratedCaseDirectives: () => stripGeneratedCaseDirectives,
+  titleKindFor: () => titleKindFor,
   typeExprToDirective: () => typeExprToDirective2,
   unifiedDiff: () => unifiedDiff,
   validateSchemaNode: () => validateSchemaNode,
+  wrapReturnNullable: () => wrapReturnNullable,
   writeInterfaceDraft: () => writeInterfaceDraft
 });
 import { readFileSync as readFileSync19, existsSync as existsSync18 } from "fs";
@@ -278123,6 +278384,302 @@ function joinSections(base, sectionTexts) {
 `;
   return lead + normalized.join("\n");
 }
+function keyOf(node) {
+  if (!node) return void 0;
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "StringLiteral") return node.value;
+  return void 0;
+}
+function litKind(node) {
+  if (!node) return void 0;
+  if (node.type === "StringLiteral") return "string";
+  if (node.type === "NumericLiteral") return "number";
+  if (node.type === "BooleanLiteral") return "boolean";
+  return void 0;
+}
+function hintFromUse(parent, key) {
+  if (!parent) return void 0;
+  const t = parent.type;
+  if (t === "BinaryExpression") {
+    const op = parent.operator;
+    const other = key === "left" ? parent.right : parent.left;
+    const lk = litKind(other);
+    if (op === "===" || op === "==" || op === "!==" || op === "!=") {
+      if (lk === "string") return { type: "string()", via: "compare string lit" };
+      if (lk === "number") return { type: "number()", via: "compare number lit" };
+      if (lk === "boolean") return { type: "boolean()", via: "compare boolean lit" };
+    }
+    if (op === "+") {
+      if (lk === "number") return { type: "number()", via: "add number" };
+      if (lk === "string") return { type: "string()", via: "concat string" };
+      return { type: "any()", via: "add (unknown coerce)" };
+    }
+    if (op === "-" || op === "*" || op === "/" || op === "%" || op === "**") {
+      return { type: "number()", via: `arith ${op}` };
+    }
+    if (op === "<" || op === ">" || op === "<=" || op === ">=") {
+      return { type: "number()", via: `rel ${op}` };
+    }
+    return void 0;
+  }
+  if (t === "UnaryExpression" && parent.operator === "!") {
+    return { type: "boolean()", via: "truthiness" };
+  }
+  if (t === "MemberExpression" || t === "OptionalMemberExpression") {
+    const prop = keyOf(parent.property);
+    if (prop && STRING_METHODS2.has(prop) && prop !== "includes" && prop !== "indexOf" && prop !== "slice" && prop !== "concat" && prop !== "at") {
+      return { type: "string()", via: `.${prop}()` };
+    }
+    if (prop && NUMBER_METHODS.has(prop)) {
+      return { type: "number()", via: `.${prop}()` };
+    }
+    if (prop === "length") {
+      return { type: "union(string(), array(any()))", via: ".length" };
+    }
+    if (prop === "size") {
+      return { type: "any()", via: ".size (Set/Map)" };
+    }
+    if (prop && ARRAY_METHODS.has(prop)) {
+      return { type: "array(any())", via: `.${prop}()` };
+    }
+    return void 0;
+  }
+  if (t === "CallExpression" || t === "OptionalCallExpression") {
+    const callee = parent.callee;
+    const cname = callee?.type === "Identifier" ? callee.name : void 0;
+    if (cname === "String") return { type: "string()", via: "String()" };
+    if (cname === "Number") return { type: "number()", via: "Number()" };
+    if (cname === "Boolean") return { type: "boolean()", via: "Boolean()" };
+    if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.name === "Array" && callee.property?.type === "Identifier" && callee.property.name === "isArray") {
+      return { type: "array(any())", via: "Array.isArray" };
+    }
+    return void 0;
+  }
+  if (t === "UnaryExpression" && parent.operator === "typeof") {
+    return void 0;
+  }
+  return void 0;
+}
+function hintFromTypeof(typeofNode, cmp2) {
+  if (!typeofNode || !cmp2) return void 0;
+  if (typeofNode.type !== "UnaryExpression" || typeofNode.operator !== "typeof") return void 0;
+  if (cmp2.type !== "BinaryExpression") return void 0;
+  const op = cmp2.operator;
+  if (op !== "===" && op !== "==" && op !== "!==" && op !== "!=") return void 0;
+  const other = cmp2.left === typeofNode ? cmp2.right : cmp2.left;
+  const lk = litKind(other);
+  if (lk !== "string") return void 0;
+  const name = other?.value;
+  const map = {
+    string: "string()",
+    number: "number()",
+    boolean: "boolean()",
+    object: "any()",
+    function: "any()",
+    undefined: "any()",
+    bigint: "any()",
+    symbol: "any()"
+  };
+  const type = name ? map[name] : void 0;
+  if (!type) return void 0;
+  return { type, via: `typeof === "${name}"` };
+}
+function collectParamBodyReadTypes(source) {
+  const out = /* @__PURE__ */ new Map();
+  let ast;
+  try {
+    ast = parse2(source);
+  } catch {
+    return out;
+  }
+  const visitFn = (fnName, fnNode, paramNames) => {
+    if (paramNames.size === 0) return;
+    const byParam = /* @__PURE__ */ new Map();
+    const add2 = (pname, field, hint) => {
+      if (!byParam.has(pname)) byParam.set(pname, /* @__PURE__ */ new Map());
+      const fields = byParam.get(pname);
+      if (!fields.has(field)) fields.set(field, []);
+      if (hint) fields.get(field).push(hint);
+    };
+    const walk = (node, shadowed, parent, parentKey) => {
+      if (!node || typeof node !== "object") return;
+      const n = node;
+      if ((n.type === "VariableDeclarator" || n.type === "FunctionDeclaration") && n.id?.type === "Identifier") {
+        const id = n.id.name;
+        if (paramNames.has(id)) shadowed = new Set(shadowed).add(id);
+      }
+      if (n.type === "UnaryExpression" && n.operator === "typeof") {
+        const arg = n.argument;
+        const mem = arg;
+        if (mem && (mem.type === "MemberExpression" || mem.type === "OptionalMemberExpression")) {
+          const obj2 = mem.object;
+          const prop = mem.property;
+          if (obj2?.type === "Identifier" && paramNames.has(obj2.name) && !shadowed.has(obj2.name) && prop && mem.computed !== true) {
+            const key = keyOf(prop);
+            const pname = obj2.name;
+            if (key !== void 0) {
+              const gp = parent;
+              add2(pname, key, hintFromTypeof(n, gp));
+            }
+          }
+        }
+      }
+      if (n.type === "MemberExpression" || n.type === "OptionalMemberExpression") {
+        const obj2 = n.object;
+        const prop = n.property;
+        const computed = n.computed === true;
+        if (obj2?.type === "Identifier" && paramNames.has(obj2.name) && !shadowed.has(obj2.name) && prop && !computed) {
+          const key = keyOf(prop);
+          const pname = obj2.name;
+          if (key !== void 0) {
+            const hint = hintFromUse(parent, parentKey ?? "object");
+            add2(pname, key, hint);
+          }
+        }
+      }
+      for (const k of Object.keys(n)) {
+        if (k === "loc" || k === "start" || k === "end") continue;
+        const child = n[k];
+        if (Array.isArray(child)) {
+          for (const item of child) walk(item, shadowed, n, k);
+        } else if (child && typeof child === "object") {
+          walk(child, shadowed, n, k);
+        }
+      }
+    };
+    walk(fnNode, /* @__PURE__ */ new Set());
+    if (byParam.size === 0) return;
+    const fieldsOf = /* @__PURE__ */ new Map();
+    for (const [pname, fieldMap] of byParam) {
+      const list = [];
+      for (const [field, hints] of fieldMap) {
+        list.push({ field, ...mergeHints(hints) });
+      }
+      list.sort((a, b) => a.field < b.field ? -1 : 1);
+      fieldsOf.set(pname, list);
+    }
+    out.set(fnName, fieldsOf);
+  };
+  const paramSet = (fnNode) => {
+    const names2 = /* @__PURE__ */ new Set();
+    const params = fnNode.params ?? [];
+    for (const p of params) {
+      if (!p) continue;
+      if (p.type === "Identifier") names2.add(p.name);
+      else if (p.type === "AssignmentPattern" && p.left?.type === "Identifier") {
+        names2.add(p.left.name);
+      } else if (p.type === "RestElement" && p.argument?.type === "Identifier") {
+        names2.add(p.argument.name);
+      } else if (p.type === "ObjectPattern") {
+        for (const prop of p.properties ?? []) {
+          if (prop.type === "ObjectProperty") {
+            const v2 = prop.value;
+            if (v2.type === "Identifier") names2.add(v2.name);
+            else if (v2.type === "AssignmentPattern" && v2.left?.type === "Identifier") {
+              names2.add(v2.left.name);
+            }
+          }
+        }
+      }
+    }
+    return names2;
+  };
+  const visitClassMethods = (className, classNode) => {
+    const body = classNode.body?.body ?? [];
+    for (const m of body) {
+      const mem = m;
+      const isMethod3 = mem.type === "MethodDefinition" || mem.type === "ClassMethod" || mem.type === "TSDeclareMethod";
+      if (!isMethod3 || mem.static) continue;
+      if (mem.kind && mem.kind !== "method") continue;
+      const keyName = mem.key?.type === "Identifier" ? mem.key.name : void 0;
+      if (!keyName) continue;
+      const methodNode = mem.type === "MethodDefinition" ? mem.value : mem;
+      if (!methodNode) continue;
+      visitFn(`${className}.${keyName}`, methodNode, paramSet(methodNode));
+    }
+  };
+  const considerDecl = (decl, exported) => {
+    if (!decl) return;
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      const id = decl.id;
+      visitFn(id.name, decl, paramSet(decl));
+      return;
+    }
+    if (decl.type === "ClassDeclaration" && decl.id?.name) {
+      visitClassMethods(decl.id.name, decl);
+      return;
+    }
+    if (decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations ?? []) {
+        const id = d.id;
+        const init = d.init;
+        if (exported && id?.type === "Identifier" && init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) {
+          visitFn(id.name, init, paramSet(init));
+        }
+      }
+    }
+  };
+  const program3 = ast.program;
+  const bodyStmts = program3?.body ?? [];
+  for (const stmt of bodyStmts) {
+    if (stmt.type === "ExportNamedDeclaration") {
+      considerDecl(stmt.declaration, true);
+    } else if (stmt.type === "ExportDefaultDeclaration") {
+      considerDecl(stmt.declaration, true);
+    } else if (stmt.type === "ClassDeclaration") {
+      const id = stmt.id;
+      if (id?.name) visitClassMethods(id.name, stmt);
+    } else if (stmt.type === "FunctionDeclaration") {
+      considerDecl(stmt, false);
+    }
+  }
+  return out;
+}
+function mergeHints(hints) {
+  if (hints.length === 0) return { type: "any()", via: "read (no type evidence)" };
+  const types2 = [...new Set(hints.map((h) => h.type))];
+  if (types2.length === 1) {
+    return { type: types2[0], via: hints[0].via };
+  }
+  const concrete = types2.filter((t) => t !== "any()");
+  if (concrete.length === 0) return { type: "any()", via: hints[0].via };
+  if (concrete.length === 1) {
+    const h = hints.find((x) => x.type === concrete[0]);
+    return { type: concrete[0], via: h.via };
+  }
+  const specific = concrete.filter((t) => !t.startsWith("union("));
+  if (specific.length === 1) {
+    const h = hints.find((x) => x.type === specific[0]);
+    return { type: specific[0], via: h.via };
+  }
+  if (specific.length > 1) {
+    return {
+      type: `union(${specific.join(", ")})`,
+      via: hints.filter((h) => specific.includes(h.type)).map((h) => h.via).join(" + ")
+    };
+  }
+  const flat = /* @__PURE__ */ new Set();
+  for (const t of concrete) {
+    if (t.startsWith("union(") && t.endsWith(")")) {
+      for (const part of t.slice(6, -1).split(",")) flat.add(part.trim());
+    } else {
+      flat.add(t);
+    }
+  }
+  const parts = [...flat];
+  return {
+    type: parts.length === 1 ? parts[0] : `union(${parts.join(", ")})`,
+    via: hints.map((h) => h.via).join(" + ")
+  };
+}
+function bodyReadFieldsFor(map, fnName, paramName2) {
+  return map.get(fnName)?.get(paramName2);
+}
+function shapeDslFromFields(fields) {
+  if (fields.length === 0) return "shape({})";
+  const parts = fields.map((f) => `${f.field}: ${f.type}`);
+  return `shape({ ${parts.join(", ")} })`;
+}
 function collectParamBodyAccesses(source) {
   const out = /* @__PURE__ */ new Map();
   let ast;
@@ -278131,7 +278688,7 @@ function collectParamBodyAccesses(source) {
   } catch {
     return out;
   }
-  const keyOf = (node) => {
+  const keyOf2 = (node) => {
     if (node.type === "Identifier") return node.name;
     if (node.type === "StringLiteral") return node.value;
     return void 0;
@@ -278153,7 +278710,7 @@ function collectParamBodyAccesses(source) {
         const prop = n.property;
         const computed = n.computed === true;
         if (obj2?.type === "Identifier" && paramNames.has(obj2.name) && !shadowed.has(obj2.name) && prop && !computed) {
-          const key = keyOf(prop);
+          const key = keyOf2(prop);
           const pname = obj2.name;
           if (key !== void 0) {
             if (!byParam.has(pname)) byParam.set(pname, /* @__PURE__ */ new Set());
@@ -278332,7 +278889,7 @@ function litPrimOf(c) {
   if (typeof v2 === "boolean") return "boolean";
   return c.members?.[0] ? litPrimOf(c.members[0]) : void 0;
 }
-function projectDraftParams(fn2, paramCases, bodyByParam, formals) {
+function projectDraftParams(fn2, paramCases, bodyByParam, formals, bodyReadByParam) {
   const bodyFor = (name, index2) => {
     if (!bodyByParam) return void 0;
     const hit = bodyByParam.get(name);
@@ -278346,8 +278903,23 @@ function projectDraftParams(fn2, paramCases, bodyByParam, formals) {
     }
     return bodyByParam.get(`_p${index2}`);
   };
+  const fieldsFor = (name, index2) => {
+    if (!bodyReadByParam) return void 0;
+    const hit = bodyReadByParam.get(name);
+    if (hit && hit.length > 0) return hit;
+    const formal = formals?.[index2];
+    if (formal && formal.kind === "pattern") {
+      for (const b of formal.bound) {
+        const boundHit = bodyReadByParam.get(b);
+        if (boundHit && boundHit.length > 0) return boundHit;
+      }
+    }
+    return bodyReadByParam.get(`_p${index2}`);
+  };
   return fn2.paramNames.map((name, i) => {
     const bodyAccesses = bodyFor(name, i) ? [...bodyFor(name, i)].sort() : void 0;
+    const bodyReadFields = fieldsFor(name, i);
+    const bodyExtra = bodyReadFields ? { bodyAccesses: bodyReadFields.map((f) => f.field), bodyReadFields } : bodyAccesses ? { bodyAccesses } : {};
     const argAbs = [];
     for (const c of paramCases) {
       const a = c.argAbs[i];
@@ -278355,11 +278927,12 @@ function projectDraftParams(fn2, paramCases, bodyByParam, formals) {
     }
     if (argAbs.length === 0) {
       if (bodyAccesses && bodyAccesses.length > 0) {
+        const shapeText = bodyReadFields ? shapeDslFromFields(bodyReadFields) : `shape({ ${bodyAccesses.map((k) => `${k}: any()`).join(", ")} })`;
         return {
           name,
-          display: `/* body-read { ${bodyAccesses.join(", ")} } \u2014 fill types when accepting */`,
+          display: `/* body-read ${shapeText} */`,
           projected: false,
-          bodyAccesses
+          ...bodyExtra
         };
       }
       return { name, display: "/* no evidence \u2014 tighten */", projected: false };
@@ -278370,7 +278943,7 @@ function projectDraftParams(fn2, paramCases, bodyByParam, formals) {
         name,
         display: `/* not projectable: ${argAbs.map((a) => formatShape(a)).join(" | ")} */`,
         projected: false,
-        ...bodyAccesses ? { bodyAccesses } : {}
+        ...bodyExtra
       };
     }
     const constraint = widenDraftConstraint(raw);
@@ -278380,7 +278953,7 @@ function projectDraftParams(fn2, paramCases, bodyByParam, formals) {
         name,
         display: `/* observed: ${observed2} \u2014 widen/confirm before accepting */`,
         projected: false,
-        ...bodyAccesses ? { bodyAccesses } : {}
+        ...bodyExtra
       };
     }
     let display = formatConstraint(constraint);
@@ -278388,7 +278961,9 @@ function projectDraftParams(fn2, paramCases, bodyByParam, formals) {
     if (observed !== display) {
       display += `  /* observed: ${observed} */`;
     }
-    if (bodyAccesses && bodyAccesses.length > 0) {
+    if (bodyReadFields && bodyReadFields.length > 0) {
+      display += `  /* body also reads: ${shapeDslFromFields(bodyReadFields)} */`;
+    } else if (bodyAccesses && bodyAccesses.length > 0) {
       display += `  /* body also reads: ${bodyAccesses.join(", ")} */`;
     }
     return {
@@ -278396,7 +278971,7 @@ function projectDraftParams(fn2, paramCases, bodyByParam, formals) {
       constraint,
       display,
       projected: true,
-      ...bodyAccesses ? { bodyAccesses } : {}
+      ...bodyExtra
     };
   });
 }
@@ -278483,8 +279058,8 @@ function suggestedBodyDsl(fnName, params) {
   const withBody = params.filter((p) => p.bodyAccesses && p.bodyAccesses.length > 0 && !p.projected);
   if (withBody.length === 0) return void 0;
   const parts = withBody.map((p) => {
-    const fields = p.bodyAccesses.map((k) => `${k}: /* TODO */`).join(", ");
-    return `${p.name}: shape({ ${fields} })`;
+    const shapeText = p.bodyReadFields ? shapeDslFromFields(p.bodyReadFields) : `shape({ ${p.bodyAccesses.map((k) => `${k}: any()`).join(", ")} })`;
+    return `${p.name}: ${shapeText}`;
   });
   return `//   suggested (body-read, not a contract): ${sanitizeCommentText(
     `${fnName} = fn({ ${parts.join(", ")} })`
@@ -278499,6 +279074,7 @@ async function draftInterface(filePath, opts = {}) {
   const exported = localNamedExports(source);
   const selected = opts.fnNames && opts.fnNames.length > 0 ? new Set(opts.fnNames) : exported;
   const bodyMap = wantBody ? collectParamBodyAccesses(source) : /* @__PURE__ */ new Map();
+  const bodyReadTypes = wantBody ? collectParamBodyReadTypes(source) : /* @__PURE__ */ new Map();
   const entries = [];
   for (const fn2 of analysis.functions) {
     if (!selected.has(fn2.name) && !opts.fnNames?.includes(fn2.name)) continue;
@@ -278547,7 +279123,8 @@ async function draftInterface(filePath, opts = {}) {
     }
     const { paramCases, returnCases, paramEvidence, rawReturnEvidence } = caseEvidence(fn2);
     const bodyByParam = bodyMap.get(fn2.name);
-    const params = projectDraftParams(fn2, paramCases, bodyByParam, fn2.formals);
+    const bodyReadByParam = bodyReadTypes.get(fn2.name);
+    const params = projectDraftParams(fn2, paramCases, bodyByParam, fn2.formals, bodyReadByParam);
     const ret = projectDraftReturn(fn2, returnCases, source, rawReturnEvidence, loadModule, filePath);
     const { evidence: returnEvidence, ...returns } = ret;
     let evidence = paramEvidence;
@@ -280780,7 +281357,287 @@ function serializeCaseJson(result, file) {
   if (external) json.externalFunctions = external;
   return json;
 }
-var GENERATED_PREFIX, GENERATED_CASE_LINE_REGEX, IDENT_KEY_REGEX, NUMBER_LITERAL_REGEX, UNSAFE_STRING_CHARS, UNSAFE_KEY_CHARS, CONTROL_CHARS, DIFF_CONTEXT, GENERATED_HEADER, NameAllocator, DERIVED_HEADER, TS_PARAM_RESERVED, DIALECT_RENDERERS, CHECK_FN_SOURCE;
+function titlePrefix(k) {
+  return `[${k}]`;
+}
+function titleKindFor(code2, action) {
+  switch (action.kind) {
+    case "draft":
+      return "fix";
+    case "relax":
+      return code2 === "nudo:unproven-return" ? "review" : "silence";
+    case "mock":
+    case "assume":
+    case "emit":
+      return "scaffold";
+    case "ignore-throws":
+      return "silence";
+    case "callsite":
+      return "fix";
+    default:
+      return "adjust";
+  }
+}
+function escapeRegExp22(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findFnDeclStart(lines, fnName) {
+  const re = new RegExp(
+    `(?:export\\s+)?(?:async\\s+)?function\\s+(?<![\\w$])${escapeRegExp22(fnName)}(?![\\w$])|(?:export\\s+)?const\\s+(?<![\\w$])${escapeRegExp22(fnName)}(?![\\w$])\\s*=`
+  );
+  for (let i = 0; i < lines.length; i++) {
+    if (re.test(lines[i])) {
+      let j = i - 1;
+      while (j >= 0 && (lines[j].trim() === "" || lines[j].trim().startsWith("*") || lines[j].trim().startsWith("/*") || lines[j].trim().startsWith("//"))) {
+        if (lines[j].includes("/**") || lines[j].trim().startsWith("//")) return j;
+        j--;
+      }
+      return i;
+    }
+  }
+  return -1;
+}
+function addThrowsAnnotation(source, fnName, kind) {
+  const lines = source.split("\n");
+  const start = findFnDeclStart(lines, fnName);
+  if (start < 0) return void 0;
+  const kindSafe = kind.replace(/[^\w.$]/g, "") || "Error";
+  const tag = ` * @nudo:throws ${kindSafe}`;
+  for (let i = Math.max(0, start - 15); i < Math.min(lines.length, start + 3); i++) {
+    if (lines[i].includes(`@nudo:throws ${kindSafe}`)) return { edits: [] };
+  }
+  for (let i = start; i < Math.min(lines.length, start + 30); i++) {
+    const t = lines[i];
+    const closeIdx = t.indexOf("*/");
+    const openIdx = t.indexOf("/**");
+    if (openIdx !== -1 && closeIdx > openIdx) {
+      const inner = t.slice(openIdx + 3, closeIdx).trim();
+      const innerLine = inner ? ` * ${inner}
+` : "";
+      return {
+        edits: [
+          {
+            startLine: i,
+            startCol: 0,
+            endLine: i,
+            endCol: t.length,
+            newText: `/**
+${innerLine}${tag}
+ */`
+          }
+        ]
+      };
+    }
+    if (closeIdx !== -1) {
+      return {
+        edits: [
+          {
+            startLine: i,
+            startCol: 0,
+            endLine: i,
+            endCol: 0,
+            newText: `${tag}
+`
+          }
+        ]
+      };
+    }
+    if (t.trim().startsWith("/**")) continue;
+    if (i > start && !t.trim().startsWith("*") && !t.trim().startsWith("/*")) break;
+  }
+  return {
+    edits: [
+      {
+        startLine: start,
+        startCol: 0,
+        endLine: start,
+        endCol: 0,
+        newText: `/**
+${tag}
+ */
+`
+      }
+    ]
+  };
+}
+function wrapReturnNullable(sidecarSource, fnName) {
+  const fn2 = escapeRegExp22(fnName);
+  const startRe = new RegExp(
+    `(?:export\\s+const\\s+${fn2}\\s*=\\s*|(?<![\\w$])${fn2}\\s*=\\s*)fn\\s*\\(`
+  );
+  const m = sidecarSource.match(startRe);
+  if (!m || m.index === void 0) return void 0;
+  const start = m.index;
+  const open = start + m[0].lastIndexOf("(");
+  let depth = 0;
+  let end = -1;
+  for (let i = open; i < sidecarSource.length; i++) {
+    const ch = sidecarSource[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end < 0) return void 0;
+  const region = sidecarSource.slice(start, end + 1);
+  let argDepth = 0;
+  let comma = -1;
+  for (let i = open + 1; i < end; i++) {
+    const ch = sidecarSource[i];
+    if (ch === "(" || ch === "{" || ch === "[") argDepth++;
+    else if (ch === ")" || ch === "}" || ch === "]") argDepth--;
+    else if (ch === "," && argDepth === 0) {
+      comma = i;
+      break;
+    }
+  }
+  if (comma < 0) return void 0;
+  let retStart = comma + 1;
+  while (retStart < end && /\s/.test(sidecarSource[retStart])) retStart++;
+  const retExpr = sidecarSource.slice(retStart, end).trim();
+  if (!retExpr || retExpr.startsWith("nullable(") || retExpr.startsWith("union(")) {
+    return void 0;
+  }
+  const next = sidecarSource.slice(0, retStart) + `nullable(${retExpr})` + sidecarSource.slice(end);
+  return next;
+}
+function addBudgetAnnotation(source, fnName, forks = 64) {
+  const lines = source.split("\n");
+  const start = findFnDeclStart(lines, fnName);
+  if (start < 0) return void 0;
+  if (source.includes(`@nudo:budget`)) return { edits: [] };
+  return {
+    edits: [
+      {
+        startLine: start,
+        startCol: 0,
+        endLine: start,
+        endCol: 0,
+        newText: `/**
+ * @nudo:budget forks=${forks}
+ */
+`
+      }
+    ]
+  };
+}
+function applyTextEdits(source, edits) {
+  const lines = source.split("\n");
+  const sorted = [...edits].sort(
+    (a, b) => b.startLine - a.startLine || b.startCol - a.startCol
+  );
+  for (const e of sorted) {
+    const before = lines.slice(0, e.startLine);
+    const after = lines.slice(e.endLine + 1);
+    const startLineText = lines[e.startLine] ?? "";
+    const endLineText = lines[e.endLine] ?? startLineText;
+    const merged = startLineText.slice(0, e.startCol) + e.newText + endLineText.slice(e.endCol);
+    lines.splice(e.startLine, e.endLine - e.startLine + 1, merged);
+  }
+  return lines.join("\n");
+}
+function materializeAction(input) {
+  const { code: code2, action, fn: fn2, source, sidecarText, sidecarPath } = input;
+  const tk = titleKindFor(code2, action);
+  if (code2 === "nudo:entry-may-throw" && action.kind === "relax" && fn2) {
+    const kind = input.throwsKind ?? input.suggestion?.match(/@nudo:throws\s+(\w+)/)?.[1] ?? "Error";
+    const r = addThrowsAnnotation(source, fn2, kind);
+    if (!r) return void 0;
+    return {
+      titleKind: "silence",
+      title: `${titlePrefix("silence")} Declare @nudo:throws ${kind} on ${fn2}`,
+      edits: r.edits
+    };
+  }
+  if (code2 === "nudo:entry-may-throw" && action.kind === "draft" && fn2) {
+    const bodyRead = input.suggestion?.match(/body-read\s*\{([^}]+)\}/)?.[1];
+    const fieldNames = bodyRead?.split(",").map((s) => s.trim()).filter(Boolean);
+    const inferred = collectParamBodyReadTypes(source).get(fn2);
+    let fields;
+    let paramName2 = "arg";
+    if (inferred) {
+      for (const [pname, list] of inferred) {
+        if (fieldNames && fieldNames.length > 0) {
+          const hit = list.filter((f) => fieldNames.includes(f.field));
+          if (hit.length > 0) {
+            fields = hit;
+            paramName2 = pname;
+            break;
+          }
+        } else if (list.length > 0) {
+          fields = list;
+          paramName2 = pname;
+          break;
+        }
+      }
+    }
+    if (!fields || fields.length === 0) {
+      if (!fieldNames || fieldNames.length === 0) {
+        return {
+          titleKind: "fix",
+          title: `${titlePrefix("fix")} Add sidecar param contract for ${fn2} (via nudo contract --draft)`,
+          edits: [],
+          openPath: sidecarPath
+        };
+      }
+      fields = fieldNames.map((f) => ({ field: f, type: "any()", via: "read (no type evidence)" }));
+    }
+    const shapeText = shapeDslFromFields(fields);
+    const clause = `export const ${fn2} = fn({ ${paramName2}: ${shapeText} });
+`;
+    const next = sidecarText && sidecarText.trim().length > 0 ? sidecarText.endsWith("\n") ? sidecarText + clause : sidecarText + "\n" + clause : `// Generated by quickfix \u2014 review before accepting
+${clause}`;
+    return {
+      titleKind: "fix",
+      title: `${titlePrefix("fix")} Add sidecar param contract for ${fn2} (${fields.map((f) => `${f.field}: ${f.type}`).join(", ")})`,
+      edits: [],
+      sidecar: { path: sidecarPath, newText: next },
+      openPath: sidecarPath
+    };
+  }
+  if (code2 === "nudo:constraint-violated" && (action.kind === "relax" || action.kind === "draft") && fn2 && sidecarText && (/nullish/i.test(input.suggestion ?? "") || /nullish/i.test(input.expected ?? "") || /use nullable/i.test(input.suggestion ?? ""))) {
+    const next = wrapReturnNullable(sidecarText, fn2);
+    if (next && next !== sidecarText) {
+      return {
+        titleKind: "fix",
+        title: `${titlePrefix("fix")} Wrap ${fn2} return contract in nullable(\u2026)`,
+        edits: [],
+        sidecar: { path: sidecarPath, newText: next }
+      };
+    }
+  }
+  if (code2 === "nudo:unproven-return" && action.kind === "relax" && fn2 && sidecarText) {
+    return {
+      titleKind: "review",
+      title: `${titlePrefix("review")} Relax return contract for ${fn2} to inferred surface`,
+      edits: [],
+      openPath: sidecarPath
+    };
+  }
+  if (code2 === "nudo:recursion-truncated" && fn2) {
+    const r = addBudgetAnnotation(source, fn2);
+    if (!r) return void 0;
+    return {
+      titleKind: "adjust",
+      title: `${titlePrefix("adjust")} Add @nudo:budget forks=64 on ${fn2}`,
+      edits: r.edits
+    };
+  }
+  if ((code2 === "nudo:unknown-inference" || code2 === "nudo:opaque-result") && (action.kind === "mock" || action.kind === "draft")) {
+    return {
+      titleKind: "scaffold",
+      title: `${titlePrefix("scaffold")} ${action.label}`,
+      edits: [],
+      openPath: code2 === "nudo:opaque-result" ? input.file : sidecarPath
+    };
+  }
+  return void 0;
+}
+var GENERATED_PREFIX, GENERATED_CASE_LINE_REGEX, IDENT_KEY_REGEX, NUMBER_LITERAL_REGEX, UNSAFE_STRING_CHARS, UNSAFE_KEY_CHARS, CONTROL_CHARS, DIFF_CONTEXT, GENERATED_HEADER, STRING_METHODS2, NUMBER_METHODS, ARRAY_METHODS, NameAllocator, DERIVED_HEADER, TS_PARAM_RESERVED, DIALECT_RENDERERS, CHECK_FN_SOURCE;
 var init_emit2 = __esm({
   "../service/dist/emit/index.js"() {
     "use strict";
@@ -280795,6 +281652,7 @@ var init_emit2 = __esm({
     init_internal();
     init_src2();
     init_src2();
+    init_src2();
     init_src();
     init_internal();
     init_src();
@@ -280817,6 +281675,66 @@ var init_emit2 = __esm({
     CONTROL_CHARS = /[\x00-\x1f\x7f]/;
     DIFF_CONTEXT = 3;
     GENERATED_HEADER = "// @generated by nudo \u2014 do not edit; regenerate with `nudo contract --emit`";
+    STRING_METHODS2 = /* @__PURE__ */ new Set([
+      "toLowerCase",
+      "toUpperCase",
+      "trim",
+      "trimStart",
+      "trimEnd",
+      "slice",
+      "substring",
+      "substr",
+      "charAt",
+      "charCodeAt",
+      "codePointAt",
+      "includes",
+      "startsWith",
+      "endsWith",
+      "split",
+      "replace",
+      "replaceAll",
+      "repeat",
+      "padStart",
+      "padEnd",
+      "normalize",
+      "concat",
+      "match",
+      "matchAll",
+      "search",
+      "at",
+      "indexOf",
+      "lastIndexOf"
+    ]);
+    NUMBER_METHODS = /* @__PURE__ */ new Set([
+      "toFixed",
+      "toPrecision",
+      "toExponential",
+      "valueOf"
+    ]);
+    ARRAY_METHODS = /* @__PURE__ */ new Set([
+      "map",
+      "filter",
+      "reduce",
+      "forEach",
+      "find",
+      "findIndex",
+      "some",
+      "every",
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "sort",
+      "reverse",
+      "join",
+      "flat",
+      "flatMap",
+      "includes",
+      "indexOf",
+      "slice",
+      "splice",
+      "concat"
+    ]);
     NameAllocator = class {
       taken;
       constructor(initial) {
@@ -282690,6 +283608,109 @@ async function runCheck(file, opts = {}) {
     process.exitCode = 1;
   }
 }
+async function runCheckFix(opts) {
+  const core = await Promise.resolve().then(() => (init_src(), src_exports));
+  const { checkSource: checkSource2, pTrue: pTrue3, sidecarPathOf: sidecarPathOf2, actionsForIssue: actionsForIssue2 } = core;
+  const { collectSkipReturns: collectSkipReturns2, defaultLoadModule: defaultLoadModule3 } = await Promise.resolve().then(() => (init_src4(), src_exports4));
+  const {
+    materializeAction: materializeAction2,
+    applyTextEdits: applyTextEdits2,
+    unifiedDiff: unifiedDiff2
+  } = await Promise.resolve().then(() => (init_emit2(), emit_exports));
+  const { writeFileSync: writeFileSync11, readFileSync: readFileSync29, existsSync: existsSync26 } = await import("fs");
+  const only = opts.only && opts.only.length > 0 ? new Set(opts.only) : void 0;
+  let planned = 0;
+  let written = 0;
+  for (const file of opts.targets) {
+    let source;
+    try {
+      source = readFileSync29(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const report = checkSource2(file, source, pTrue3, {
+      loadModule: defaultLoadModule3,
+      fromFile: file,
+      ...opts.ignoreThrows ? { ignoreThrows: opts.ignoreThrows } : {},
+      ...opts.entryThrows ? { entryThrows: opts.entryThrows } : {},
+      skips: collectSkipReturns2(source)
+    });
+    const sidecar = sidecarPathOf2(file);
+    let sidecarText;
+    try {
+      sidecarText = existsSync26(sidecar) ? readFileSync29(sidecar, "utf-8") : void 0;
+    } catch {
+      sidecarText = void 0;
+    }
+    for (const issue of report.issues) {
+      if (only && !only.has(issue.code)) continue;
+      const acts = issue.actions ?? actionsForIssue2(issue);
+      const throwsKind = issue.suggestion?.match(/@nudo:throws\s+(\w+)/)?.[1] ?? issue.actual?.match(/throws\s+([A-Za-z]+)/)?.[1];
+      const rank = (k) => k === "fix" ? 0 : k === "adjust" ? 1 : 2;
+      const plans = [];
+      for (const action of acts) {
+        if (action.kind === "info") continue;
+        const plan2 = materializeAction2({
+          code: issue.code,
+          fn: issue.fn,
+          file,
+          source,
+          sidecarText,
+          sidecarPath: sidecar,
+          action,
+          throwsKind,
+          expected: issue.expected,
+          suggestion: issue.suggestion
+        });
+        if (plan2) plans.push(plan2);
+      }
+      plans.sort((a, b) => rank(a.titleKind) - rank(b.titleKind));
+      const plan = plans.find((p) => rank(p.titleKind) <= 1);
+      if (!plan) continue;
+      if (plan.edits.length > 0) {
+        const next = applyTextEdits2(source, plan.edits);
+        if (next !== source) {
+          planned++;
+          console.log(`
+--- ${file}`);
+          console.log(`+++ ${file}  (${plan.title})`);
+          console.log(unifiedDiff2(source, next, file) || "(no line diff)");
+          if (opts.write) {
+            writeFileSync11(file, next, "utf-8");
+            source = next;
+            written++;
+          }
+        }
+      }
+      if (plan.sidecar) {
+        const cur = sidecarText ?? "";
+        const next = plan.sidecar.newText;
+        if (next !== cur) {
+          planned++;
+          console.log(`
+--- ${plan.sidecar.path}`);
+          console.log(`+++ ${plan.sidecar.path}  (${plan.title})`);
+          console.log(unifiedDiff2(cur, next, plan.sidecar.path) || "(new file)");
+          if (opts.write) {
+            writeFileSync11(plan.sidecar.path, next, "utf-8");
+            sidecarText = next;
+            written++;
+          }
+        }
+      }
+    }
+  }
+  const mode = opts.write ? "written" : "planned (dry-run)";
+  console.log(
+    `
+check --fix: ${planned} edit(s) ${mode}${opts.write ? `, ${written} applied` : " \u2014 pass --write to apply"}`
+  );
+  if (!opts.write && planned > 0) {
+    console.log(
+      "hint: only [fix]/[adjust] are auto-applied; [silence]/[review] need a human (or LSP quickfix)"
+    );
+  }
+}
 function registerCheckCommand(program3) {
   program3.command("check").description("Gate contracts + entry throws; print signatures (CI). Day 0 observation lives here.").argument("<paths...>", "File(s) or directory(s) to check").option("--watch, -w", "Watch files and re-run check on change").option("--json", "Emit stable CheckJson (1 file) or CheckJsonMulti envelope (N files) for CI / Agent").option("--gha", "GitHub Actions inline annotations (::error/::warning). Auto when GITHUB_ACTIONS=true").option("--gitlab", "GitLab Code Quality JSON array (write as gl-code-quality-report.json)").option("--verbose", "Expand Abs signatures (term/pred/conf detail)").option("--abs", "Algebra face: term/pred/conf per function").option("--fn <name>", "With --abs: only this function").option("--assume <pred...>", "With --abs: assume constraints, e.g. x>0 y>=1").option("--generalize", "With --abs: polymorphic signatures via symbolic execution").option(
     "--from <paths...>",
@@ -282706,7 +283727,7 @@ function registerCheckCommand(program3) {
   ).option(
     "--what-if <binding...>",
     "AI3: assume `name:type` bindings (e.g. raw:string) and report --target"
-  ).option("--target <name>", "With --what-if: binding name whose inferred type to print").action(
+  ).option("--target <name>", "With --what-if: binding name whose inferred type to print").option("--fix", "Materialize one fix/adjust edit per issue (default --dry-run: print unified diff)").option("--only <codes...>", "With --fix: only these diagnostic codes (e.g. nudo:entry-may-throw)").option("--write", "With --fix: apply edits to disk (default dry-run)").option("--dry-run", "With --fix: print diffs only (default; kept for explicitness)").action(
     async (paths, opts) => {
       if (opts.whatIf && opts.whatIf.length > 0) {
         const targets2 = [];
@@ -282764,6 +283785,17 @@ function registerCheckCommand(program3) {
       }
       const entryThrows = isEntryThrowsMode(opts.entryThrows) ? opts.entryThrows : void 0;
       const profile = isGateProfile(opts.profile) ? opts.profile : void 0;
+      if (opts.fix) {
+        await runCheckFix({
+          targets,
+          only: opts.only,
+          write: opts.write === true,
+          ignoreThrows,
+          entryThrows,
+          profile
+        });
+        return;
+      }
       const shared = {
         from: externalRecords,
         verbose: opts.verbose,