@nudojs/core 1.4.0 → 1.5.0

package/dist/{chunk-LFCF6BLE.js → chunk-W2MP6REI.js}

@@ -1757,6 +1757,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);
@@ -3734,8 +3738,320 @@ function migrateInvariants(from, to) {
   if (f) propFlagsTable.set(to, new Map(f));
 }
 
-// src/algebra/builtins/shared.ts
+// src/algebra/exec/runtime/state.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+
+// src/algebra/containers.ts
+var TUPLE_LITERAL_CAP = 8;
+function shouldWidenArrayLiteral(n) {
+  return n > TUPLE_LITERAL_CAP;
+}
+var TUPLE_MATERIALIZE_CAP = 4096;
+function widenedArrayConf() {
+  return "path";
+}
+
+// src/algebra/exec/runtime/state.ts
+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;
+}
+var phi = pTrue;
+function currentExecPhi() {
+  return phi;
+}
+function withExecPhi(p, body) {
+  const prev = phi;
+  phi = p;
+  try {
+    return body();
+  } finally {
+    phi = prev;
+  }
+}
 var noBody = { type: "BlockStatement", body: [], directives: [] };
+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");
+}
+var loopExitsAls = new AsyncLocalStorage2();
+var throwExitsAls = new AsyncLocalStorage2();
+var tryMarksAls = new AsyncLocalStorage2();
+var softFrameActiveAls = new AsyncLocalStorage2();
+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;
+}
+var NudoReturn = class extends Error {
+  absValue;
+  constructor(absValue) {
+    super("nudo:return");
+    this.name = "NudoReturn";
+    this.absValue = absValue;
+  }
+};
+function isNudoReturn(e) {
+  return e instanceof NudoReturn;
+}
+function $loopReturn(v2) {
+  throw new NudoReturn(v2);
+}
+var NudoLoopSignal = class extends Error {
+  kind;
+  label;
+  constructor(kind, label) {
+    super("nudo:loop");
+    this.name = "NudoLoopSignal";
+    this.kind = kind;
+    this.label = label;
+  }
+};
+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;
+}
+
+// src/algebra/builtins/shared.ts
+var noBody2 = { type: "BlockStatement", body: [], directives: [] };
 function numPrim(conf = "path") {
   return abs({ k: "prim", type: "number" }, void 0, void 0, conf);
 }
@@ -3770,13 +4086,199 @@ function coerceMathArg(a) {
   if (v2 === void 0) return void 0;
   return "throw";
 }
-function mathMethod(name) {
-  if (!Object.hasOwn(Math, name)) return void 0;
-  const impl = Math[name];
-  return typeof impl === "function" ? impl : void 0;
+function mathMethod(name) {
+  if (!Object.hasOwn(Math, name)) return void 0;
+  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 = [];
@@ -3952,16 +4454,6 @@ function isObjectProtoBrand(a) {
   return !!a && a.shape.k === "brand" && a.shape.name === "Object.prototype";
 }
 
-// src/algebra/containers.ts
-var TUPLE_LITERAL_CAP = 8;
-function shouldWidenArrayLiteral(n) {
-  return n > TUPLE_LITERAL_CAP;
-}
-var TUPLE_MATERIALIZE_CAP = 4096;
-function widenedArrayConf() {
-  return "path";
-}
-
 // src/algebra/builtins/object.ts
 function assignSourceSlots(src) {
   const s = src.shape;
@@ -4546,8 +5038,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": {
@@ -5403,7 +5906,7 @@ function arrayJoinToString(recv) {
 }
 function arrayMethodAbs(name) {
   return absFunction(["thisArg"], {
-    body: noBody,
+    body: noBody2,
     bindThis: true,
     apply: (a) => {
       const recv = a[0] ?? undefAbs();
@@ -5766,11 +6269,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();
@@ -6453,7 +6956,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();
@@ -11428,349 +11931,49 @@ ${inner}
       if (fn.async) {
         return `$fnVal(${nameList}, (${argsParamParts.join(", ")}) => $async(() => ${bodySrc}))`;
       }
-      return `$fnVal(${nameList}, (${argsParamParts.join(", ")}) => ${bodySrc})`;
-    }
-    case "MetaProperty":
-      return "$importMeta()";
-    case "ImportExpression": {
-      const specSrc = transpileExpression(expr.source, opts);
-      return `$dynamicImport(${specSrc})`;
-    }
-    case "JSXElement":
-    case "JSXFragment":
-      return "$unknown()";
-    default:
-      throw new NudoUnsupportedError(
-        `expression:${expr.type}`,
-        expr.loc ? { line: expr.loc.start.line, column: expr.loc.start.column } : void 0
-      );
-  }
-}
-bindTranspileExpression(transpileExpression);
-bindTranspileShortCircuit(transpileShortCircuitExpr);
-
-// src/algebra/exec/transpile.ts
-function transpileSource(source, opts = {}) {
-  const file = parseSource(source);
-  return transpileFile(file, { ...opts, source: opts.source ?? source });
-}
-function runtimeImportOf(runtime) {
-  return `import { $add, $sub, $mul, $div, $mod, $bitand, $bitor, $bitxor, $bitnot, $shl, $shr, $ushr, $pow, $toNumber, $toNumeric, $updateAdd, $updateSub, $in, $instanceof, $instanceofNonIdent, $classExpr, $del, $delRes, $objAccessor, $neg, $typeof, $not, $eq, $ne, $eqLoose, $neLoose, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $setProto, $while, $whileSeq, $arr, $arrWithHoles, $arrMutContainer, $idx, $idxSet, $len, $call, $throw, $loopReturn, $loopBreak, $loopContinue, $class, $new, $invoke, $invokeSuper, $super, $async, $copy, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $forInKeys, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal, $regex, $reStateCall, $rethrowIfNudoReturn, $nullishTest, $tryMark, $assignRecord, $recordBinding, $unknown, $importMeta, $dynamicImport, $tryTakeSince, $tryCurrentMark, $tryPopMark, $tryDigestSoftCatch, $tryReleaseSoftOut, $tryDetachSoftCatch, $tryDiscardSoft, $tryOrphanSoft, $pushLoopExit, $objRest, $arrRest, $elems, $arguments, $isForkExit, $rawThis, $isBreakTo } from ${JSON.stringify(runtime)};`;
-}
-function transpileFile(file, opts = {}) {
-  const runtime = opts.runtimeImport ?? "@nudojs/core/exec";
-  const lines = [
-    `// nudo evaluator transpile \u2014 values are Abs; operators are overloaded calls`,
-    `import { $add, $sub, $mul, $div, $mod, $bitand, $bitor, $bitxor, $bitnot, $shl, $shr, $ushr, $pow, $toNumber, $toNumeric, $updateAdd, $updateSub, $in, $instanceof, $instanceofNonIdent, $classExpr, $del, $delRes, $objAccessor, $neg, $typeof, $not, $eq, $ne, $eqLoose, $neLoose, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $setProto, $while, $whileSeq, $arr, $arrWithHoles, $arrMutContainer, $idx, $idxSet, $len, $call, $throw, $loopReturn, $loopBreak, $loopContinue, $class, $new, $invoke, $invokeSuper, $super, $async, $copy, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $forInKeys, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal, $regex, $reStateCall, $rethrowIfNudoReturn, $nullishTest, $tryMark, $assignRecord, $recordBinding, $unknown, $importMeta, $dynamicImport, $tryTakeSince, $tryCurrentMark, $tryPopMark, $tryDigestSoftCatch, $tryReleaseSoftOut, $tryDetachSoftCatch, $tryDiscardSoft, $tryOrphanSoft, $pushLoopExit, $objRest, $arrRest, $elems, $arguments, $isForkExit, $rawThis, $isBreakTo } from ${JSON.stringify(runtime)};`,
-    ``
-  ];
-  for (const stmt of file.program.body) {
-    lines.push(transpileStatement(stmt, 0, opts));
-  }
-  return lines.join("\n") + "\n";
-}
-function transpile(source, opts) {
-  return transpileSource(source, opts);
-}
-
-// 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;
-}
-var phi = pTrue;
-function currentExecPhi() {
-  return phi;
-}
-function withExecPhi(p, body) {
-  const prev = phi;
-  phi = p;
-  try {
-    return body();
-  } finally {
-    phi = prev;
-  }
-}
-var noBody2 = { type: "BlockStatement", body: [], directives: [] };
-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;
+      return `$fnVal(${nameList}, (${argsParamParts.join(", ")}) => ${bodySrc})`;
+    }
+    case "MetaProperty":
+      return "$importMeta()";
+    case "ImportExpression": {
+      const specSrc = transpileExpression(expr.source, opts);
+      return `$dynamicImport(${specSrc})`;
+    }
+    case "JSXElement":
+    case "JSXFragment":
+      return "$unknown()";
     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");
-}
-var loopExitsAls = new AsyncLocalStorage2();
-var throwExitsAls = new AsyncLocalStorage2();
-var tryMarksAls = new AsyncLocalStorage2();
-var softFrameActiveAls = new AsyncLocalStorage2();
-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();
+      throw new NudoUnsupportedError(
+        `expression:${expr.type}`,
+        expr.loc ? { line: expr.loc.start.line, column: expr.loc.start.column } : void 0
+      );
   }
 }
-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;
-}
-var NudoReturn = class extends Error {
-  absValue;
-  constructor(absValue) {
-    super("nudo:return");
-    this.name = "NudoReturn";
-    this.absValue = absValue;
-  }
-};
-function isNudoReturn(e) {
-  return e instanceof NudoReturn;
+bindTranspileExpression(transpileExpression);
+bindTranspileShortCircuit(transpileShortCircuitExpr);
+
+// src/algebra/exec/transpile.ts
+function transpileSource(source, opts = {}) {
+  const file = parseSource(source);
+  return transpileFile(file, { ...opts, source: opts.source ?? source });
 }
-function $loopReturn(v2) {
-  throw new NudoReturn(v2);
+function runtimeImportOf(runtime) {
+  return `import { $add, $sub, $mul, $div, $mod, $bitand, $bitor, $bitxor, $bitnot, $shl, $shr, $ushr, $pow, $toNumber, $toNumeric, $updateAdd, $updateSub, $in, $instanceof, $instanceofNonIdent, $classExpr, $del, $delRes, $objAccessor, $neg, $typeof, $not, $eq, $ne, $eqLoose, $neLoose, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $setProto, $while, $whileSeq, $arr, $arrWithHoles, $arrMutContainer, $idx, $idxSet, $len, $call, $throw, $loopReturn, $loopBreak, $loopContinue, $class, $new, $invoke, $invokeSuper, $super, $async, $copy, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $forInKeys, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal, $regex, $reStateCall, $rethrowIfNudoReturn, $nullishTest, $tryMark, $assignRecord, $recordBinding, $unknown, $importMeta, $dynamicImport, $tryTakeSince, $tryCurrentMark, $tryPopMark, $tryDigestSoftCatch, $tryReleaseSoftOut, $tryDetachSoftCatch, $tryDiscardSoft, $tryOrphanSoft, $pushLoopExit, $objRest, $arrRest, $elems, $arguments, $isForkExit, $rawThis, $isBreakTo } from ${JSON.stringify(runtime)};`;
 }
-var NudoLoopSignal = class extends Error {
-  kind;
-  label;
-  constructor(kind, label) {
-    super("nudo:loop");
-    this.name = "NudoLoopSignal";
-    this.kind = kind;
-    this.label = label;
+function transpileFile(file, opts = {}) {
+  const runtime = opts.runtimeImport ?? "@nudojs/core/exec";
+  const lines = [
+    `// nudo evaluator transpile \u2014 values are Abs; operators are overloaded calls`,
+    `import { $add, $sub, $mul, $div, $mod, $bitand, $bitor, $bitxor, $bitnot, $shl, $shr, $ushr, $pow, $toNumber, $toNumeric, $updateAdd, $updateSub, $in, $instanceof, $instanceofNonIdent, $classExpr, $del, $delRes, $objAccessor, $neg, $typeof, $not, $eq, $ne, $eqLoose, $neLoose, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $setProto, $while, $whileSeq, $arr, $arrWithHoles, $arrMutContainer, $idx, $idxSet, $len, $call, $throw, $loopReturn, $loopBreak, $loopContinue, $class, $new, $invoke, $invokeSuper, $super, $async, $copy, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $forInKeys, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal, $regex, $reStateCall, $rethrowIfNudoReturn, $nullishTest, $tryMark, $assignRecord, $recordBinding, $unknown, $importMeta, $dynamicImport, $tryTakeSince, $tryCurrentMark, $tryPopMark, $tryDigestSoftCatch, $tryReleaseSoftOut, $tryDetachSoftCatch, $tryDiscardSoft, $tryOrphanSoft, $pushLoopExit, $objRest, $arrRest, $elems, $arguments, $isForkExit, $rawThis, $isBreakTo } from ${JSON.stringify(runtime)};`,
+    ``
+  ];
+  for (const stmt of file.program.body) {
+    lines.push(transpileStatement(stmt, 0, opts));
   }
-};
-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;
+  return lines.join("\n") + "\n";
 }
-function $rethrowIfNudoReturn(e) {
-  if (isNudoReturn(e)) throw e;
+function transpile(source, opts) {
+  return transpileSource(source, opts);
 }
 
 // src/algebra/exec/runtime/ops.ts
@@ -13052,7 +13255,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
           });
         }
@@ -13071,7 +13274,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") {
@@ -13082,7 +13285,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);
@@ -13098,14 +13301,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);
@@ -13114,7 +13317,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 });
         }
       }
     }
@@ -16535,7 +16738,7 @@ function $instanceofNonIdent(_left) {
 }
 function $classExpr() {
   return absFunction(["_rest"], {
-    body: noBody2,
+    body: noBody,
     apply: () => unknown
   });
 }
@@ -16797,6 +17000,43 @@ export {
   getPropFlags,
   setPropFlags,
   migrateInvariants,
+  clearStaleTermPred,
+  currentExecPhi,
+  withExecPhi,
+  asAbsVal,
+  callAtFunctionBoundary,
+  $fnVal,
+  $rawThis,
+  $lit,
+  litTruth,
+  isDefinitelyTrue,
+  isDefinitelyFalse,
+  runWithLoopExits,
+  takeLoopExits,
+  takeThrowExits,
+  pushLoopExit,
+  pushThrowExit,
+  $pushLoopExit,
+  $tryMark,
+  $tryCurrentMark,
+  $tryPopMark,
+  $tryTakeSince,
+  $tryDigestSoftCatch,
+  $tryReleaseSoftCatch,
+  $tryDetachSoftCatch,
+  $tryDiscardSoft,
+  $tryOrphanSoft,
+  $tryReleaseSoftOut,
+  NudoReturn,
+  isNudoReturn,
+  $loopReturn,
+  NudoLoopSignal,
+  $loopBreak,
+  $loopContinue,
+  isNudoBreak,
+  isNudoContinue,
+  $isBreakTo,
+  $rethrowIfNudoReturn,
   evalMathMethod,
   builtinCtorAbs,
   builtinCtorNameOf,
@@ -16965,43 +17205,6 @@ export {
   runtimeImportOf,
   transpileFile,
   transpile,
-  clearStaleTermPred,
-  currentExecPhi,
-  withExecPhi,
-  asAbsVal,
-  callAtFunctionBoundary,
-  $fnVal,
-  $rawThis,
-  $lit,
-  litTruth,
-  isDefinitelyTrue,
-  isDefinitelyFalse,
-  runWithLoopExits,
-  takeLoopExits,
-  takeThrowExits,
-  pushLoopExit,
-  pushThrowExit,
-  $pushLoopExit,
-  $tryMark,
-  $tryCurrentMark,
-  $tryPopMark,
-  $tryTakeSince,
-  $tryDigestSoftCatch,
-  $tryReleaseSoftCatch,
-  $tryDetachSoftCatch,
-  $tryDiscardSoft,
-  $tryOrphanSoft,
-  $tryReleaseSoftOut,
-  NudoReturn,
-  isNudoReturn,
-  $loopReturn,
-  NudoLoopSignal,
-  $loopBreak,
-  $loopContinue,
-  isNudoBreak,
-  isNudoContinue,
-  $isBreakTo,
-  $rethrowIfNudoReturn,
   $unknown,
   $importMeta,
   $dynamicImport,

package/dist/{chunk-7QUVTEYZ.js → chunk-YO4GKCNE.js}

@@ -45,7 +45,7 @@ import {
   withEvalBudgetOverride,
   withExecPhi,
   withFnBudgetOverride
-} from "./chunk-LFCF6BLE.js";
+} from "./chunk-W2MP6REI.js";
 
 // src/algebra/directive-scan.ts
 function cleanDirectiveLine(raw, kind) {

package/dist/exec.js

@@ -176,7 +176,7 @@ import {
   tryRunTranspiled,
   withEvalBudgetOverride,
   withExecPhi
-} from "./chunk-LFCF6BLE.js";
+} from "./chunk-W2MP6REI.js";
 export {
   $add,
   $arguments,

package/dist/index.d.ts

@@ -365,7 +365,12 @@ declare function setPropFlags(o: Abs, key: string, f: PropFlags): void;
 declare function migrateInvariants(from: Abs, to: Abs): void;
 
 /**
- * Math.* — 字面量实参走 ToNumber/ToInt32 后调用原生折叠，否则 number
+ * Math.* — 字面量实参走 ToNumber/ToInt32 后调用原生折叠；非字面量对
+ * min/max/round/floor/ceil/trunc 透传数值区间（#68）。
+ *
+ * NaN 策略（DEC：显式 NaN 臂）：操作数可能为 NaN 时结果为
+ * `NaN | number@bounds`。契约 `ge(0).le(100)` 对 NaN 臂诚实报违例；
+ * `if (Number.isNaN(n)) return …` 假臂的 `ne(n, NaN)` 事实可排除 NaN 臂。
  */
 
 declare function evalMathMethod(name: string, args: Abs[]): Abs | undefined;

package/dist/index.js

@@ -91,7 +91,7 @@ import {
   takeRefineDiagsSince,
   throwConstraintToKinds,
   union
-} from "./chunk-7QUVTEYZ.js";
+} from "./chunk-YO4GKCNE.js";
 import {
   $add,
   $arguments,
@@ -507,7 +507,7 @@ import {
   v,
   withExecPhi,
   withVar
-} from "./chunk-LFCF6BLE.js";
+} from "./chunk-W2MP6REI.js";
 
 // src/environment.ts
 function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
@@ -768,60 +768,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 phi = 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, phi);
+  }
+  return assertImpliesSingle(arms[0], constraint, opts, phi);
+}
+function assertSumArms(arms, parent, constraint, opts, phi) {
+  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, phi);
+    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, phi) {
+  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, phi);
+  return assertScalar(arm, constraint, phi);
 }
 function isAnyConstraint(c) {
   return !c.prim && c.preds.length === 0 && !c.fields && !c.element && !c.members && !c.fn && !isIntFlag(c);
@@ -2214,7 +2246,7 @@ function checkSourceInner(filePath, source, file, phi, 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 } : {}
@@ -2259,7 +2291,7 @@ function checkSourceInner(filePath, source, file, phi, 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 } : {}
@@ -2627,6 +2659,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 [

package/dist/internal.js

@@ -18,7 +18,7 @@ import {
   stableAnalyzeKeySource,
   stablePathKey,
   stablePathKeyGraph
-} from "./chunk-7QUVTEYZ.js";
+} from "./chunk-YO4GKCNE.js";
 import {
   $tryDigestSoft,
   $tryMarkSoft,
@@ -157,7 +157,7 @@ import {
   withEvalBudgetOverride,
   withFnBudgetOverride,
   wrapPromise
-} from "./chunk-LFCF6BLE.js";
+} from "./chunk-W2MP6REI.js";
 
 // src/algebra/inlay.ts
 function listFunctions(source) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/core",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "engines": {
     "node": ">=20"
   },