@nudojs/core 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,3 +1,260 @@
+import {
+  $add,
+  $arr,
+  $async,
+  $asyncReturn,
+  $await,
+  $call,
+  $callNamed,
+  $catchVal,
+  $class,
+  $concat,
+  $div,
+  $elems,
+  $eq,
+  $fnVal,
+  $for,
+  $forIter,
+  $forOf,
+  $fork,
+  $ge,
+  $gen,
+  $get,
+  $gt,
+  $idx,
+  $idxSet,
+  $invoke,
+  $invokeSuper,
+  $join,
+  $le,
+  $len,
+  $lit,
+  $lt,
+  $mod,
+  $mul,
+  $ne,
+  $neg,
+  $new,
+  $not,
+  $obj,
+  $optionalGet,
+  $optionalInvoke,
+  $orDefault,
+  $set,
+  $setKey,
+  $spread,
+  $staticInvoke,
+  $sub,
+  $super,
+  $switch,
+  $thisGet,
+  $thisSet,
+  $throw,
+  $typeof,
+  $while,
+  $whileSeq,
+  $yield,
+  DEFAULT_MAX_LOOP_ITERS,
+  MAX_CALL_DEPTH,
+  MAX_TOTAL_CALLS,
+  NudoThrow,
+  abs,
+  absFunction,
+  absToString,
+  add,
+  alphaOf,
+  analyzeFn,
+  and,
+  anyVar,
+  app,
+  applyAbsFn,
+  applyCallbackAbs,
+  asAbs,
+  asAbsVal,
+  attachFnImpl,
+  awaitAbs,
+  betaOf,
+  bindImports,
+  bool,
+  boolLit,
+  callAbsMethod,
+  callFunction,
+  callTranspiledExport,
+  callTranspiledExportFull,
+  classFromMethods,
+  clearBClasses,
+  cmp,
+  coerceAsyncReturn,
+  collapseToOptional,
+  collectAbsExports,
+  collectAbsNodeTypes,
+  concatString,
+  confJoin,
+  createHofCollectCtx,
+  createTemplateAbs,
+  currentExecPhi,
+  defaultLeakBudget,
+  defineClass,
+  definitelyNotNullishShape,
+  div,
+  emptyEnv,
+  emptyPhi,
+  eq,
+  evalArrayStatic,
+  evalBuiltinInstanceMethod,
+  evalBuiltinNew,
+  evalDateCtor,
+  evalDateMethod,
+  evalDateStatic,
+  evalGlobalFn,
+  evalJsonMethod,
+  evalMathMethod,
+  evalMethodBody,
+  evalNamespaceCall,
+  evalNode,
+  evalNumberStatic,
+  evalObjectMethod,
+  evalProgramAbs,
+  evalPromiseCtor,
+  evalPromiseStatic,
+  evalRegExpCtor,
+  evalRegExpMethod,
+  evalSource,
+  exceedsBudget,
+  falseConstraint,
+  findAbsAtPosition,
+  fnOf,
+  ge,
+  geNum,
+  getAbsOrigin,
+  getAbsProperty,
+  getBCallCollector,
+  getBClass,
+  getClass,
+  getClassChain,
+  getFnImpl,
+  getParseSourceCacheSize,
+  gt,
+  gtNum,
+  implies,
+  instanceOf,
+  instantiateClass,
+  instantiateReturn,
+  isDefinitelyFalse,
+  isDefinitelyTrue,
+  isExactLit,
+  isNudoThrow,
+  isNullishLitAbs,
+  isNumPrim,
+  isObj,
+  isRelFn,
+  isStrPrim,
+  isTemplateLike,
+  joinAbs,
+  joinFunctions,
+  joinObjects,
+  joinValues,
+  le,
+  leNum,
+  leakIfNeeded,
+  leqAbs,
+  lit,
+  litValue,
+  lookupMethod,
+  lookupMethodWithOwner,
+  lookupSuperMethod,
+  lt,
+  ltNum,
+  makeSum,
+  mapElementFallback,
+  maybeLeak,
+  mod,
+  mul,
+  ne,
+  negAbs,
+  never,
+  not,
+  notAbs,
+  noteMemberDispatchMiss,
+  notePrimMemberMissing,
+  noteUnknownMemberMissing,
+  num,
+  numLit,
+  numVar,
+  numericBounds,
+  obj,
+  objOf,
+  or,
+  pFalse,
+  pTrue,
+  parseSource,
+  phiAnd,
+  predEquals,
+  predToString,
+  predVars,
+  projectBrand,
+  projectFlatMapResult,
+  promoteParamShape,
+  ptypeof,
+  recordMemberDiag,
+  registerBClass,
+  relationFingerprint,
+  relationFn,
+  resetAbsCallBudget,
+  resetLeakCounter,
+  resetParseSourceCache,
+  runTranspiled,
+  setAbsAssignCollector,
+  setAbsCallCollector,
+  setAbsNodeCollector,
+  setAbsTruncationCollector,
+  setApplyCallbackHost,
+  setBCallCollector,
+  setMemberDiagCollector,
+  shapeOfTerm,
+  shapeOnlyFn,
+  shapeToString,
+  simplifyTerm,
+  snapshotAbs,
+  spread,
+  str,
+  strLit,
+  strictEqAbs,
+  stripTypes,
+  sub,
+  substAbs,
+  substPred,
+  substPredAbs,
+  superNameOf,
+  tagAbsOrigin,
+  templatePartsOf,
+  termDepth,
+  termEquals,
+  termNodes,
+  termToString,
+  transpile,
+  transpileExpression,
+  transpileFile,
+  transpileSource,
+  trueConstraint,
+  tryPromoteDirectCall,
+  tryPromoteForOfIteratee,
+  tryPromoteHofCallback,
+  tryPromoteReceiverAsArr,
+  typeofAbs,
+  undefAbs,
+  unknown,
+  v,
+  withExecPhi,
+  withVar,
+  wrapPromise
+} from "./chunk-BU4A6XJ3.js";
+
+// src/refinements/template-predicates.ts
+function isTemplate(tv) {
+  return tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts);
+}
+
 // src/type-value.ts
 function createUnion(...members) {
   return simplifyUnion(members);
@@ -37,7 +294,17 @@ var T = {
     kind: "refined",
     base,
     refinement
-  })
+  }),
+  fnSig: (paramTypes, returnType, throwsType = { kind: "never" }, impl) => {
+    const dummy = {
+      kind: "function",
+      params: paramTypes.map((_p, i) => `_arg${i}`),
+      body: { type: "BlockStatement", body: [], directives: [] },
+      closure: null
+    };
+    dummy._signature = { paramTypes, returnType, throwsType, impl };
+    return dummy;
+  }
 };
 function typeValueEquals(a, b) {
   if (a.kind !== b.kind) return false;
@@ -60,6 +327,23 @@ function typeValueEquals(a, b) {
   return a === b;
 }
 function simplifyUnion(members) {
+  if (members.length === 0) return T.never;
+  if (members.length === 1) return members[0].kind === "never" ? T.never : members[0];
+  if (members.length === 2) {
+    const a = members[0];
+    const b = members[1];
+    if (a.kind !== "union" && b.kind !== "union") {
+      if (a.kind === "never") return b.kind === "never" ? T.never : b;
+      if (b.kind === "never") return a;
+      if (typeValueEquals(a, b)) return a;
+      if (a.kind === "unknown" || b.kind === "unknown") return T.unknown;
+      const aBase = absorbablePrimitiveBase(a);
+      if (aBase !== void 0 && typeValueEquals(aBase, b)) return b;
+      const bBase = absorbablePrimitiveBase(b);
+      if (bBase !== void 0 && typeValueEquals(bBase, a)) return a;
+      return { kind: "union", members: [a, b] };
+    }
+  }
   const flat = [];
   for (const m of members) {
     if (m.kind === "never") continue;
@@ -75,30 +359,54 @@ function simplifyUnion(members) {
       deduped.push(m);
     }
   }
-  if (deduped.length === 0) return T.never;
-  if (deduped.length === 1) return deduped[0];
-  if (deduped.some((m) => m.kind === "unknown")) return T.unknown;
-  return { kind: "union", members: deduped };
+  const primitives = deduped.filter((m) => m.kind === "primitive");
+  const absorbed = primitives.length > 0 ? deduped.filter((m) => {
+    const base = absorbablePrimitiveBase(m);
+    return base === void 0 || !primitives.some((p) => typeValueEquals(p, base));
+  }) : deduped;
+  if (absorbed.length === 0) return T.never;
+  if (absorbed.length === 1) return absorbed[0];
+  if (absorbed.some((m) => m.kind === "unknown")) return T.unknown;
+  return { kind: "union", members: absorbed };
+}
+function absorbablePrimitiveBase(tv) {
+  if (tv.kind === "literal") {
+    const widened = widenLiteral(tv);
+    return widened.kind === "primitive" ? widened : void 0;
+  }
+  if (isTemplate(tv)) return T.string;
+  return void 0;
 }
 function widenLiteral(tv) {
   if (tv.kind !== "literal") return tv;
-  const v = tv.value;
-  if (typeof v === "number") return T.number;
-  if (typeof v === "string") return T.string;
-  if (typeof v === "boolean") return T.boolean;
-  if (v === null) return T.null;
-  if (v === void 0) return T.undefined;
+  const v2 = tv.value;
+  if (typeof v2 === "number") return T.number;
+  if (typeof v2 === "string") return T.string;
+  if (typeof v2 === "boolean") return T.boolean;
+  if (typeof v2 === "bigint") return T.bigint;
+  if (v2 === null) return T.null;
+  if (v2 === void 0) return T.undefined;
   return T.unknown;
 }
+function collapseLiteralUnion(tv, maxLiterals) {
+  if (tv.kind !== "union") return tv;
+  if (tv.members.length <= maxLiterals) return tv;
+  const simplified = simplifyUnion(tv.members);
+  if (simplified.kind !== "union") return simplified;
+  if (!simplified.members.every((m) => m.kind === "literal")) return simplified;
+  const first = widenLiteral(simplified.members[0]);
+  if (!simplified.members.every((m) => typeValueEquals(widenLiteral(m), first))) return simplified;
+  return first;
+}
 function isSubtypeOf(a, b) {
   if (b.kind === "unknown") return true;
   if (a.kind === "never") return true;
   if (typeValueEquals(a, b)) return true;
   if (a.kind === "literal" && b.kind === "primitive") {
-    const v = a.value;
-    if (b.type === "number" && typeof v === "number") return true;
-    if (b.type === "string" && typeof v === "string") return true;
-    if (b.type === "boolean" && typeof v === "boolean") return true;
+    const v2 = a.value;
+    if (b.type === "number" && typeof v2 === "number") return true;
+    if (b.type === "string" && typeof v2 === "string") return true;
+    if (b.type === "boolean" && typeof v2 === "boolean") return true;
     return false;
   }
   if (a.kind === "literal" && b.kind === "refined") {
@@ -161,8 +469,8 @@ function deepCloneTypeValue(tv, idMap) {
       map.set(tv.id, newId);
     }
     const newProps = {};
-    for (const [k, v] of Object.entries(tv.properties)) {
-      newProps[k] = deepCloneTypeValue(v, map);
+    for (const [k, v2] of Object.entries(tv.properties)) {
+      newProps[k] = deepCloneTypeValue(v2, map);
     }
     return { kind: "object", properties: newProps, id: newId };
   }
@@ -177,8 +485,8 @@ function deepCloneTypeValue(tv, idMap) {
   }
   if (tv.kind === "instance") {
     const newProps = {};
-    for (const [k, v] of Object.entries(tv.properties)) {
-      newProps[k] = deepCloneTypeValue(v, map);
+    for (const [k, v2] of Object.entries(tv.properties)) {
+      newProps[k] = deepCloneTypeValue(v2, map);
     }
     return { kind: "instance", className: tv.className, properties: newProps };
   }
@@ -205,13 +513,27 @@ function mergeObjectProperties(a, b) {
   return { kind: "object", properties: merged, id: a.id };
 }
 function typeValueToString(tv) {
+  return typeValueToStringInner(tv, /* @__PURE__ */ new Set());
+}
+function typeValueToStringInner(tv, seen, depth = 0) {
+  if (depth > 48) return "\u2026";
+  const recur = (inner) => {
+    if (inner && typeof inner === "object") {
+      if (seen.has(inner)) return "\u2026";
+      seen.add(inner);
+      const out = typeValueToStringInner(inner, seen, depth + 1);
+      seen.delete(inner);
+      return out;
+    }
+    return typeValueToStringInner(inner, seen, depth + 1);
+  };
   switch (tv.kind) {
     case "literal": {
-      const v = tv.value;
-      if (v === null) return "null";
-      if (v === void 0) return "undefined";
-      if (typeof v === "string") return JSON.stringify(v);
-      return String(v);
+      const v2 = tv.value;
+      if (v2 === null) return "null";
+      if (v2 === void 0) return "undefined";
+      if (typeof v2 === "string") return JSON.stringify(v2);
+      return String(v2);
     }
     case "primitive":
       return tv.type;
@@ -220,29 +542,34 @@ function typeValueToString(tv) {
     case "object": {
       const entries = Object.entries(tv.properties);
       if (entries.length === 0) return "{}";
-      const inner = entries.map(([k, v]) => `${k}: ${typeValueToString(v)}`).join(", ");
+      const inner = entries.map(([k, v2]) => `${k}: ${recur(v2)}`).join(", ");
       return `{ ${inner} }`;
     }
     case "array":
-      return `${typeValueToString(tv.element)}[]`;
+      return `${recur(tv.element)}[]`;
     case "tuple": {
-      const inner = tv.elements.map(typeValueToString).join(", ");
+      const inner = tv.elements.map(recur).join(", ");
       return `[${inner}]`;
     }
     case "function": {
+      const sig = getFnSig(tv);
+      if (sig) {
+        const params2 = sig.paramTypes.map((p, i) => `${tv.params[i]}: ${recur(p)}`).join(", ");
+        return `(${params2}) => ${recur(sig.returnType)}`;
+      }
       const params = tv.params.join(", ");
       return `(${params}) => ...`;
     }
     case "promise":
-      return `Promise<${typeValueToString(tv.value)}>`;
+      return `Promise<${recur(tv.value)}>`;
     case "instance": {
       const entries = Object.entries(tv.properties);
       if (entries.length === 0) return tv.className;
-      const inner = entries.map(([k, v]) => `${k}: ${typeValueToString(v)}`).join(", ");
+      const inner = entries.map(([k, v2]) => `${k}: ${recur(v2)}`).join(", ");
       return `${tv.className} { ${inner} }`;
     }
     case "union": {
-      return tv.members.map(typeValueToString).join(" | ");
+      return tv.members.map(recur).join(" | ");
     }
     case "never":
       return "never";
@@ -261,9 +588,9 @@ function subtractType(tv, predicate) {
 }
 function getPrimitiveTypeOf(tv) {
   if (tv.kind === "literal") {
-    const v = tv.value;
-    if (v === null) return "object";
-    return typeof v;
+    const v2 = tv.value;
+    if (v2 === null) return "object";
+    return typeof v2;
   }
   if (tv.kind === "primitive") return tv.type;
   if (tv.kind === "refined") return getPrimitiveTypeOf(tv.base);
@@ -277,6 +604,15 @@ function getPrimitiveTypeOf(tv) {
 function getRefinedBase(tv) {
   return tv.kind === "refined" ? getRefinedBase(tv.base) : tv;
 }
+function isFnSig(tv) {
+  return tv.kind === "function" && "_signature" in tv;
+}
+function getFnSig(tv) {
+  if (tv.kind === "function" && "_signature" in tv) {
+    return tv._signature;
+  }
+  return void 0;
+}
 
 // src/refinements/range.ts
 function formatRangeName(meta) {
@@ -491,9 +827,6 @@ function createTemplate(parts) {
   }
   return T.refine(T.string, createTemplateRefinement(normalized));
 }
-function isTemplate(tv) {
-  return tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts);
-}
 function getTemplateParts(tv) {
   if (tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts)) {
     return tv.refinement.meta.parts;
@@ -513,11 +846,34 @@ function bothLiteral(l, r) {
   }
   return null;
 }
+function isNullishLiteral(tv) {
+  return tv.kind === "literal" && (tv.value === null || tv.value === void 0);
+}
+function definitelyNotNullish(tv) {
+  switch (tv.kind) {
+    case "literal":
+      return tv.value !== null && tv.value !== void 0;
+    case "primitive":
+    case "object":
+    case "array":
+    case "tuple":
+    case "function":
+    case "instance":
+    case "promise":
+      return true;
+    case "refined":
+      return definitelyNotNullish(tv.base);
+    case "union":
+      return tv.members.every(definitelyNotNullish);
+    default:
+      return false;
+  }
+}
 var Ops = {
   add(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit) {
-      return T.literal(lit.lv + lit.rv);
+    const lit2 = bothLiteral(left, right);
+    if (lit2) {
+      return T.literal(lit2.lv + lit2.rv);
     }
     const leftIsString = isSubtypeOf(left, T.string) || isTemplate(left);
     const rightIsString = isSubtypeOf(right, T.string) || isTemplate(right);
@@ -533,97 +889,49 @@ var Ops = {
     }
     return T.union(T.number, T.string);
   },
-  sub(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit && typeof lit.lv === "number" && typeof lit.rv === "number") {
-      return T.literal(lit.lv - lit.rv);
-    }
-    return T.number;
-  },
-  mul(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit && typeof lit.lv === "number" && typeof lit.rv === "number") {
-      return T.literal(lit.lv * lit.rv);
-    }
-    return T.number;
-  },
-  div(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit && typeof lit.lv === "number" && typeof lit.rv === "number") {
-      return T.literal(lit.lv / lit.rv);
-    }
-    return T.number;
-  },
-  mod(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit && typeof lit.lv === "number" && typeof lit.rv === "number") {
-      return T.literal(lit.lv % lit.rv);
-    }
-    return T.number;
-  },
   strictEq(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv === lit.rv);
+    const lit2 = bothLiteral(left, right);
+    if (lit2) return T.literal(lit2.lv === lit2.rv);
+    if (isNullishLiteral(right) && definitelyNotNullish(left) || isNullishLiteral(left) && definitelyNotNullish(right)) {
+      return T.literal(false);
+    }
     return T.boolean;
   },
   strictNeq(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv !== lit.rv);
+    const lit2 = bothLiteral(left, right);
+    if (lit2) return T.literal(lit2.lv !== lit2.rv);
+    if (isNullishLiteral(right) && definitelyNotNullish(left) || isNullishLiteral(left) && definitelyNotNullish(right)) {
+      return T.literal(true);
+    }
     return T.boolean;
   },
   gt(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv > lit.rv);
+    const lit2 = bothLiteral(left, right);
+    if (lit2) return T.literal(lit2.lv > lit2.rv);
     return T.boolean;
   },
   lt(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv < lit.rv);
+    const lit2 = bothLiteral(left, right);
+    if (lit2) return T.literal(lit2.lv < lit2.rv);
     return T.boolean;
   },
   gte(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv >= lit.rv);
+    const lit2 = bothLiteral(left, right);
+    if (lit2) return T.literal(lit2.lv >= lit2.rv);
     return T.boolean;
   },
   lte(left, right) {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv <= lit.rv);
+    const lit2 = bothLiteral(left, right);
+    if (lit2) return T.literal(lit2.lv <= lit2.rv);
     return T.boolean;
   },
-  typeof_(operand) {
-    if (operand.kind === "literal") {
-      const v = operand.value;
-      if (v === null) return T.literal("object");
-      return T.literal(typeof v);
-    }
-    if (operand.kind === "primitive") return T.literal(operand.type);
-    if (operand.kind === "refined") return Ops.typeof_(getRefinedBase(operand));
-    if (operand.kind === "object") return T.literal("object");
-    if (operand.kind === "array" || operand.kind === "tuple")
-      return T.literal("object");
-    if (operand.kind === "function") return T.literal("function");
-    if (operand.kind === "promise") return T.literal("object");
-    if (operand.kind === "instance") return T.literal("object");
-    return T.string;
-  },
   not(operand) {
     if (operand.kind === "literal") return T.literal(!operand.value);
     return T.boolean;
-  },
-  neg(operand) {
-    if (operand.kind === "literal" && typeof operand.value === "number") {
-      return T.literal(-operand.value);
-    }
-    return T.number;
   }
 };
 var binaryOpMap = {
   "+": Ops.add,
-  "-": Ops.sub,
-  "*": Ops.mul,
-  "/": Ops.div,
-  "%": Ops.mod,
   "===": Ops.strictEq,
   "!==": Ops.strictNeq,
   ">": Ops.gt,
@@ -697,11 +1005,14 @@ function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
     },
     extend(newBindings) {
       const childMap = /* @__PURE__ */ new Map();
-      for (const [k, v] of Object.entries(newBindings)) {
-        childMap.set(k, v);
+      for (const [k, v2] of Object.entries(newBindings)) {
+        childMap.set(k, v2);
       }
       return createEnvironment(env, childMap);
     },
+    fork() {
+      return createEnvironment(env);
+    },
     has(name) {
       return store.has(name) || (parent?.has(name) ?? false);
     },
@@ -712,40 +1023,4108 @@ function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
     },
     getOwnBindings() {
       const result = {};
-      for (const [k, v] of store) {
-        result[k] = v;
+      for (const [k, v2] of store) {
+        result[k] = v2;
       }
       return result;
     }
   };
   return env;
 }
+
+// src/mock-helpers.ts
+function stub() {
+  return { kind: "mock-helper" };
+}
+stub.returns = function(value) {
+  return { kind: "mock-helper", returnValue: value };
+};
+stub.resolves = function(value) {
+  return { kind: "mock-helper", resolvedValue: value };
+};
+stub.rejects = function(value) {
+  return { kind: "mock-helper", rejectedValue: value };
+};
+stub.onFirstCall = function(value) {
+  return { kind: "mock-helper", onFirstCallValue: value };
+};
+stub.onSecondCall = function(value) {
+  return { kind: "mock-helper", onSecondCallValue: value };
+};
+stub.withArgs = function(...args) {
+  return { kind: "mock-helper", withArgsCases: [{ args, returnValue: T.unknown }] };
+};
+stub.callsFake = function(fn) {
+  return { kind: "mock-helper", callsFakeImpl: fn };
+};
+function spy() {
+  return { kind: "mock-helper" };
+}
+spy.returns = function(value) {
+  return { kind: "mock-helper", returnValue: value };
+};
+function mock() {
+  return { kind: "mock-helper" };
+}
+function mockArgMatches(declared, actual) {
+  if (actual === void 0) return false;
+  if (typeValueEquals(declared, actual)) return true;
+  if (declared.kind === "primitive" && actual.kind === "literal") {
+    const t = typeof actual.value;
+    return declared.type === "number" && t === "number" || declared.type === "string" && t === "string" || declared.type === "boolean" && t === "boolean" || declared.type === "bigint" && t === "bigint" || declared.type === "symbol" && t === "symbol";
+  }
+  return false;
+}
+function mockHelperToTypeValue(helper, env) {
+  if (helper.callsFakeImpl) {
+    if (helper.callsFakeImpl.kind === "function") {
+      return helper.callsFakeImpl;
+    }
+    const plain = T.fn(["...args"], { type: "BlockStatement", body: [] }, env);
+    plain._directReturn = helper.callsFakeImpl;
+    return plain;
+  }
+  let defaultReturn;
+  if (helper.resolvedValue) {
+    defaultReturn = T.promise(helper.resolvedValue);
+  } else if (helper.rejectedValue) {
+    defaultReturn = T.never;
+  } else if (helper.returnValue) {
+    defaultReturn = helper.returnValue;
+  } else if (helper.onFirstCallValue) {
+    defaultReturn = helper.onFirstCallValue;
+  } else {
+    defaultReturn = T.unknown;
+  }
+  if (helper.withArgsCases?.length) {
+    const cases = helper.withArgsCases;
+    return T.fnSig(
+      cases[0].args.map(() => T.unknown),
+      T.union(...cases.map((c) => c.returnValue), defaultReturn),
+      T.never,
+      (args) => {
+        for (const c of cases) {
+          if (c.args.every((a, i) => mockArgMatches(a, args[i]))) {
+            return c.returnValue;
+          }
+        }
+        return defaultReturn;
+      }
+    );
+  }
+  const body = { type: "BlockStatement", body: [] };
+  const fn = T.fn(["...args"], body, env);
+  fn._directReturn = defaultReturn;
+  return fn;
+}
+
+// src/algebra/phi.ts
+var phiStack = [pTrue];
+function currentPhi() {
+  return phiStack[phiStack.length - 1] ?? pTrue;
+}
+function pushPhi(p) {
+  phiStack.push(p);
+}
+function popPhi() {
+  if (phiStack.length > 1) phiStack.pop();
+}
+function resetPhi() {
+  phiStack = [pTrue];
+}
+function withPhiConstraint(extra, body) {
+  pushPhi(extra);
+  try {
+    body();
+  } finally {
+    popPhi();
+  }
+}
+function describePhi() {
+  const p = currentPhi();
+  return p.op === "true" ? "\u22A4" : "(phi)";
+}
+
+// src/algebra/format.ts
+function formatAbs(a, opts = {}) {
+  const showTerm = opts.showTerm !== false;
+  const showPred = opts.showPred !== false;
+  const parts = [];
+  parts.push(formatShape(a));
+  if (showTerm && a.term && a.term.op !== "lit") {
+    parts.push(`= ${termToString(a.term)}`);
+  }
+  if (showPred && a.pred && a.pred.op !== "true") {
+    parts.push(`where ${predToString(a.pred)}`);
+  }
+  parts.push(`#${a.conf}`);
+  return parts.join("  ");
+}
+function formatShapeSlot(a) {
+  const base = formatShape(a);
+  if (!a.term || a.term.op === "lit") return base;
+  if (a.shape.k === "fn" || a.shape.k === "arr") return base;
+  if (a.shape.k === "any" && a.term.op === "var") return termToString(a.term);
+  return `${base} = ${termToString(a.term)}`;
+}
+function formatShape(a) {
+  const s = a.shape;
+  switch (s.k) {
+    case "never":
+      return "never";
+    case "any":
+      return "any";
+    case "unknown":
+      return "unknown";
+    case "prim": {
+      const lv = litValue(a);
+      if (lv !== void 0) return JSON.stringify(lv);
+      return s.type;
+    }
+    case "obj": {
+      const entries = Object.entries(s.slots).map(([k, slot]) => {
+        const opt = slot.optional ? "?" : "";
+        return `${k}${opt}: ${formatShape(slot.value)}`;
+      });
+      return `{ ${entries.join(", ")} }`;
+    }
+    case "arr": {
+      if (s.element.shape.k === "any" && s.element.term?.op === "var") {
+        return `arr(${formatShapeSlot(s.element)})`;
+      }
+      return `${formatShape(s.element)}[]`;
+    }
+    case "tuple":
+      return `[${s.elements.map(formatShape).join(", ")}]`;
+    case "fn": {
+      if (s.paramTypes && s.paramTypes.length > 0) {
+        const ps = s.paramTypes.map((p) => formatShapeSlot(p));
+        const ret2 = s.returnType !== void 0 ? formatShapeSlot(s.returnType) : "?";
+        return `(${ps.join(", ")}) => ${ret2}`;
+      }
+      const ret = s.returnType !== void 0 ? formatShapeSlot(s.returnType) : "?";
+      return `(${s.params.join(", ")}) => ${ret}`;
+    }
+    case "brand":
+      return `${s.name}`;
+    case "eff":
+      return `${s.eff}<${formatShape(s.inner)}>`;
+    case "sum":
+      return s.members.map(formatShape).join(" | ");
+    default:
+      return "\xB7";
+  }
+}
+function formatAbsMultiline(a, label) {
+  const lines = [];
+  if (label) lines.push(label);
+  lines.push(`  ${formatShape(a)}`);
+  if (a.term && a.term.op !== "lit") {
+    lines.push(`  term: ${termToString(a.term)}`);
+  }
+  if (a.pred && a.pred.op !== "true") {
+    lines.push(`  pred: ${predToString(a.pred)}`);
+  }
+  lines.push(`  conf: ${a.conf}`);
+  return lines.join("\n");
+}
+
+// src/algebra/constraint.ts
+var SELF = "__nudo_self__";
+function selfTerm() {
+  return v(SELF);
+}
+function getTerm(obj2, key) {
+  return app("get", [obj2, lit(key)]);
+}
+function lenTerm(t) {
+  return app("length", [t]);
+}
+function isConstraint(x) {
+  return !!x && typeof x === "object" && x.__nudoConstraint === true;
+}
+function isNudoConstraint(x) {
+  return isConstraint(x);
+}
+function makeBuilder(prim, preds, extra) {
+  const fields = extra?.fields;
+  const element = extra?.element;
+  const isInt = extra?.int;
+  const optional = extra?.optional;
+  const base = {
+    __nudoConstraint: true,
+    ...prim ? { prim } : {},
+    preds: [...preds],
+    ...fields ? { fields } : {},
+    ...element ? { element } : {},
+    ...isInt ? { int: true } : {},
+    ...optional ? { isOptional: true } : {}
+  };
+  const add2 = (p) => makeBuilder(prim, [...preds, p], extra);
+  return Object.assign(/* @__PURE__ */ Object.create(null), base, {
+    gt: (n) => add2(gt(selfTerm(), lit(n))),
+    ge: (n) => add2(ge(selfTerm(), lit(n))),
+    lt: (n) => add2(lt(selfTerm(), lit(n))),
+    le: (n) => add2(le(selfTerm(), lit(n))),
+    int: () => makeBuilder(prim ?? "number", preds, { ...extra, int: true }),
+    min: (n) => add2(ge(lenTerm(selfTerm()), lit(n))),
+    max: (n) => add2(le(lenTerm(selfTerm()), lit(n))),
+    length: (n) => add2(and(ge(lenTerm(selfTerm()), lit(n)), le(lenTerm(selfTerm()), lit(n)))),
+    optional: () => makeBuilder(prim, preds, { ...extra, optional: true })
+  });
+}
+function number() {
+  return makeBuilder("number", []);
+}
+function string() {
+  return makeBuilder("string", []);
+}
+function boolean() {
+  return makeBuilder("boolean", []);
+}
+function array(item) {
+  if (!isConstraint(item)) return makeBuilder(void 0, []);
+  return makeBuilder(void 0, [], { element: item });
+}
+function shape(fields) {
+  const mapped = {};
+  for (const [k, v2] of Object.entries(fields)) {
+    if (!isConstraint(v2)) continue;
+    mapped[k] = {
+      constraint: v2,
+      ...v2.isOptional ? { optional: true } : {}
+    };
+  }
+  return makeBuilder(void 0, [], { fields: mapped });
+}
+function substTerm(t, paramName) {
+  if (t.op === "var" && t.id === SELF) return v(paramName);
+  if (t.op === "app" && t.fn === "get" && t.args.length === 2) {
+    return getTerm(substTerm(t.args[0], paramName), String(
+      t.args[1].op === "lit" ? t.args[1].value : ""
+    ));
+  }
+  return t;
+}
+function substPred2(p, paramName) {
+  switch (p.op) {
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+    case "eq":
+    case "ne": {
+      return { op: p.op, a: substTerm(p.a, paramName), b: substTerm(p.b, paramName) };
+    }
+    case "typeof": {
+      return { op: "typeof", t: substTerm(p.t, paramName), type: p.type };
+    }
+    case "and":
+      return and(...p.args.map((x) => substPred2(x, paramName)));
+    default:
+      return p;
+  }
+}
+function instantiateConstraint(c, paramName) {
+  if (c.fields) {
+    const parts = [];
+    for (const [key, field] of Object.entries(c.fields)) {
+      const fieldTerm = getTerm(v(paramName), key);
+      parts.push(instantiateOnTerm(field.constraint, fieldTerm));
+    }
+    if (c.prim) parts.push(ptypeof(v(paramName), c.prim));
+    if (parts.length === 0) return { op: "true" };
+    return parts.length === 1 ? parts[0] : and(...parts);
+  }
+  const preds = c.preds.map((p) => substPred2(p, paramName));
+  if (c.prim && c.preds.length === 0) {
+    return ptypeof(v(paramName), c.prim);
+  }
+  return preds.length === 0 ? { op: "true" } : preds.length === 1 ? preds[0] : and(...preds);
+}
+function instantiateOnTerm(c, t) {
+  if (c.fields) {
+    const parts = [];
+    for (const [key, field] of Object.entries(c.fields)) {
+      parts.push(instantiateOnTerm(field.constraint, getTerm(t, key)));
+    }
+    if (parts.length === 0) return { op: "true" };
+    return parts.length === 1 ? parts[0] : and(...parts);
+  }
+  const subst = (p) => {
+    switch (p.op) {
+      case "gt":
+      case "ge":
+      case "lt":
+      case "le":
+      case "eq":
+      case "ne": {
+        const a = p.a.op === "var" && p.a.id === SELF ? t : p.a;
+        const b = p.b.op === "var" && p.b.id === SELF ? t : p.b;
+        return { op: p.op, a, b };
+      }
+      case "typeof": {
+        const tt = p.t.op === "var" && p.t.id === SELF ? t : p.t;
+        return { op: "typeof", t: tt, type: p.type };
+      }
+      case "and":
+        return and(...p.args.map(subst));
+      default:
+        return p;
+    }
+  };
+  const preds = c.preds.map(subst);
+  if (c.prim && c.preds.length === 0) return ptypeof(t, c.prim);
+  return preds.length === 0 ? { op: "true" } : preds.length === 1 ? preds[0] : and(...preds);
+}
+function constraintToEntryAbs(c, paramName) {
+  const t = v(paramName);
+  if (c.fields) {
+    const slots = {};
+    for (const [key, field] of Object.entries(c.fields)) {
+      const fieldTerm = getTerm(t, key);
+      slots[key] = {
+        value: constraintOnTermAbs(field.constraint, fieldTerm),
+        ...field.optional || field.constraint.isOptional ? { optional: true } : {}
+      };
+    }
+    return abs({ k: "obj", slots }, t, void 0, "path");
+  }
+  return constraintOnTermAbs(c, t);
+}
+function constraintOnTermAbs(c, t) {
+  if (c.fields) {
+    const slots = {};
+    for (const [key, field] of Object.entries(c.fields)) {
+      slots[key] = {
+        value: constraintOnTermAbs(field.constraint, getTerm(t, key)),
+        ...field.optional || field.constraint.isOptional ? { optional: true } : {}
+      };
+    }
+    return abs({ k: "obj", slots }, t, void 0, "path");
+  }
+  if (c.element) {
+    const elem = constraintOnTermAbs(c.element, v("x[]"));
+    return abs({ k: "arr", element: elem }, t, void 0, "path");
+  }
+  const pred = instantiateOnTerm(c, t);
+  const predOut = pred.op === "true" ? void 0 : pred;
+  if (c.prim) {
+    return abs({ k: "prim", type: c.prim }, t, predOut, "path");
+  }
+  if (c.preds.length > 0) {
+    return abs({ k: "prim", type: "number" }, t, predOut, "path");
+  }
+  return abs({ k: "any" }, t, void 0, "path");
+}
+
+// src/algebra/refine.ts
+function extractNudoImports(source) {
+  const out = [];
+  const named = /@nudo:import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
+  let m;
+  while (m = named.exec(source)) {
+    const names = m[1].split(",").map((s) => s.trim()).filter(Boolean).map((s) => s.split(/\s+as\s+/).pop().trim());
+    out.push({ names, spec: m[2] });
+  }
+  const ns = /@nudo:import\s+\*\s+as\s+(\w+)\s+from\s*["']([^"']+)["']/g;
+  while (m = ns.exec(source)) {
+    out.push({ names: [`*${m[1]}`], spec: m[2] });
+  }
+  return out;
+}
+function execNudoModule(src) {
+  const names = [...src.matchAll(/export\s+const\s+(\w+)/g)].map((m) => m[1]);
+  let body = src.replace(/export\s+const\b/g, "const");
+  body = body.replace(/^\s*import\s*\{[^}]*\}\s*from\s*["'][^"']+["'];?\s*$/gm, "");
+  body = body.replace(/^\s*import\s+\*\s+as\s+\w+\s+from\s*["'][^"']+["'];?\s*$/gm, "");
+  body += `
+return { ${names.join(", ")} };`;
+  const fn = new Function("number", "string", "boolean", "shape", "array", body);
+  return fn(number, string, boolean, shape, array);
+}
+var nudoModuleExecCache = /* @__PURE__ */ new Map();
+var MAX_NUDO_MODULE_EXEC = 64;
+function execNudoModuleCached(src) {
+  const hit = nudoModuleExecCache.get(src);
+  if (hit !== void 0) {
+    nudoModuleExecCache.delete(src);
+    nudoModuleExecCache.set(src, hit);
+    return hit;
+  }
+  const out = execNudoModule(src);
+  if (nudoModuleExecCache.size >= MAX_NUDO_MODULE_EXEC) {
+    const oldest = nudoModuleExecCache.keys().next().value;
+    if (oldest !== void 0) nudoModuleExecCache.delete(oldest);
+  }
+  nudoModuleExecCache.set(src, out);
+  return out;
+}
+function resetNudoModuleExecCache() {
+  nudoModuleExecCache.clear();
+}
+function collectConstraints(source, opts) {
+  const map = /* @__PURE__ */ new Map();
+  const imports = extractNudoImports(source);
+  for (const imp of imports) {
+    if (!opts.loadModule || !opts.fromFile) continue;
+    const src = opts.loadModule(imp.spec, opts.fromFile);
+    if (!src) continue;
+    let exports;
+    try {
+      exports = execNudoModuleCached(src);
+    } catch {
+      continue;
+    }
+    for (const name of imp.names) {
+      if (name.startsWith("*")) continue;
+      const v2 = exports[name];
+      if (isNudoConstraint(v2)) map.set(name, v2);
+    }
+  }
+  return map;
+}
+function extractRefineLines(source, fnName) {
+  const fnRe = new RegExp(
+    `(?:export\\s+default\\s+)?(?:function\\s+${fnName}\\b|const\\s+${fnName}\\s*=)`
+  );
+  const m = source.match(fnRe);
+  if (!m || m.index === void 0) return [];
+  const before = source.slice(0, m.index);
+  const lines = before.split("\n");
+  const reqs = [];
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line === "" || line === "*/") continue;
+    if (line.startsWith("*") || line.startsWith("/*") || line.startsWith("//")) {
+      const rm = line.match(/@nudo:refine\s+(.+)$/);
+      if (rm) reqs.unshift(rm[1].trim().replace(/\*\/$/, "").trim());
+      continue;
+    }
+    break;
+  }
+  return reqs;
+}
+function extractRefinesFromSource(source, fnName, opts = {}) {
+  if (!source.includes("@nudo:refine")) return [];
+  const constraints = collectConstraints(source, opts);
+  const out = [];
+  for (const line of extractRefineLines(source, fnName)) {
+    const parts = line.split(/&&|,/).map((s) => s.trim()).filter(Boolean);
+    for (const part of parts) {
+      const m = part.match(/^(\w+)\s+(\w+)$/);
+      if (!m) continue;
+      const [, param, cName] = m;
+      if (param === "return") continue;
+      const c = constraints.get(cName);
+      if (!c) continue;
+      out.push({
+        param,
+        pred: instantiateConstraint(c, param),
+        constraint: c
+      });
+    }
+  }
+  return out;
+}
+function refineToIndexedFull(source, fnName, paramNames, opts = {}) {
+  const raw = extractRefinesFromSource(source, fnName, opts);
+  const out = [];
+  for (const item of raw) {
+    const idx = paramNames.indexOf(item.param);
+    if (idx >= 0) out.push([idx, item]);
+  }
+  return out;
+}
+function extractRefineReturnFromSource(source, fnName, opts = {}) {
+  if (!source.includes("@nudo:refine")) return void 0;
+  const constraints = collectConstraints(source, opts);
+  for (const line of extractRefineLines(source, fnName)) {
+    const parts = line.split(/&&|,/).map((s) => s.trim()).filter(Boolean);
+    for (const part of parts) {
+      const m = part.match(/^return\s+(\w+)$/);
+      if (!m) continue;
+      const cName = m[1];
+      const c = constraints.get(cName);
+      if (!c) continue;
+      return { name: cName, constraint: c };
+    }
+  }
+  return void 0;
+}
+
+// src/algebra/hash-source.ts
+var lastHashSource;
+var lastHashOut;
+function hashSource(s) {
+  if (s === lastHashSource && lastHashOut !== void 0) return lastHashOut;
+  let h1 = 2166136261;
+  let h2 = 2654435769;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    h1 ^= c;
+    h1 = Math.imul(h1, 16777619);
+    h2 = Math.imul(h2 ^ c, 16777619);
+  }
+  lastHashSource = s;
+  lastHashOut = `${(h1 >>> 0).toString(36)}-${(h2 >>> 0).toString(36)}_${s.length.toString(36)}`;
+  return lastHashOut;
+}
+function resetHashSourceCache() {
+  lastHashSource = void 0;
+  lastHashOut = void 0;
+}
+
+// src/algebra/fn-fp.ts
+var fnFpCache = /* @__PURE__ */ new Map();
+var MAX_FN_FP_CACHE = 24;
+var MAX_FN_FP_SOURCE_CHARS = 1e6;
+function resetFnFpCache() {
+  fnFpCache.clear();
+}
+function getFnNameAndBodies(decl) {
+  const out = [];
+  if (decl.type === "FunctionDeclaration" && decl.id) {
+    out.push({ name: decl.id.name, body: decl.body, fnNode: decl });
+    return out;
+  }
+  if (decl.type === "VariableDeclaration") {
+    for (const d of decl.declarations) {
+      if (d.id.type === "Identifier" && d.init && (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")) {
+        const comments = d.leadingComments;
+        const first = comments?.[0];
+        out.push({
+          name: d.id.name,
+          body: d.init.body,
+          fnNode: d.init,
+          declaratorStart: d.start ?? void 0,
+          declaratorLeadStart: typeof first?.start === "number" ? first.start : void 0
+        });
+      }
+    }
+  }
+  return out;
+}
+function leadingSliceStart(stmt, decl) {
+  const comments = stmt.leadingComments ?? decl.leadingComments;
+  const first = comments?.[0];
+  if (first && typeof first.start === "number") return first.start;
+  return stmt.start ?? decl.start ?? 0;
+}
+function collectSiblingRefs(node, known, out) {
+  if (!node || typeof node !== "object") return;
+  const obj2 = node;
+  if (obj2.type === "Identifier" && typeof obj2.name === "string" && known.has(obj2.name)) {
+    out.add(obj2.name);
+  }
+  for (const key of Object.keys(obj2)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") {
+      continue;
+    }
+    if ((key === "key" || key === "property") && (obj2.type === "MemberExpression" || obj2.type === "ObjectProperty" || obj2.type === "ObjectMethod" || obj2.type === "ClassMethod" || obj2.type === "ClassProperty") && obj2.computed !== true) {
+      continue;
+    }
+    if (key === "id" && (obj2.type === "FunctionDeclaration" || obj2.type === "FunctionExpression" || obj2.type === "ClassDeclaration" || obj2.type === "ClassExpression")) {
+      continue;
+    }
+    const v2 = obj2[key];
+    if (Array.isArray(v2)) {
+      for (const x of v2) collectSiblingRefs(x, known, out);
+    } else if (v2 && typeof v2 === "object") {
+      collectSiblingRefs(v2, known, out);
+    }
+  }
+}
+function computeFnFingerprints(source, file) {
+  const top = [];
+  const contextParts = [];
+  for (const stmt of file.program.body) {
+    let decl = stmt;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    } else if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    const fnInfos = getFnNameAndBodies(decl);
+    if (fnInfos.length > 0) {
+      const lead = leadingSliceStart(stmt, decl);
+      for (let i = 0; i < fnInfos.length; i++) {
+        const info = fnInfos[i];
+        const sliceStart = i === 0 ? lead : info.declaratorLeadStart ?? info.declaratorStart ?? info.fnNode.start ?? lead;
+        const end = info.fnNode.end ?? info.declaratorStart ?? decl.end ?? stmt.end ?? sliceStart;
+        top.push({
+          name: info.name,
+          slice: source.slice(sliceStart, Math.max(end, sliceStart)),
+          fnNode: info.fnNode
+        });
+      }
+    } else if (typeof stmt.start === "number" && typeof stmt.end === "number") {
+      contextParts.push(source.slice(stmt.start, stmt.end));
+    } else {
+      contextParts.push(stmt.type);
+    }
+  }
+  const context = hashSource(contextParts.join("\n "));
+  const names = new Set(top.map((t) => t.name));
+  const own = /* @__PURE__ */ new Map();
+  for (const t of top) own.set(t.name, hashSource(t.slice));
+  const edges = /* @__PURE__ */ new Map();
+  for (const t of top) {
+    const refs = /* @__PURE__ */ new Set();
+    collectSiblingRefs(t.fnNode, names, refs);
+    edges.set(t.name, refs);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const t of top) {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [...edges.get(t.name) ?? []];
+    const depParts = [];
+    while (stack.length > 0) {
+      const cur = stack.pop();
+      if (seen.has(cur)) continue;
+      seen.add(cur);
+      depParts.push(`${cur}=${own.get(cur) ?? "?"}`);
+      for (const next of edges.get(cur) ?? []) {
+        if (!seen.has(next)) stack.push(next);
+      }
+    }
+    depParts.sort();
+    result.set(t.name, {
+      own: own.get(t.name),
+      deps: hashSource(`${depParts.join(",")} ${context}`),
+      nRefs: seen.size
+    });
+  }
+  return result;
+}
+function fnFingerprints(source, file) {
+  if (source.length > MAX_FN_FP_SOURCE_CHARS) {
+    return computeFnFingerprints(source, file);
+  }
+  const hit = fnFpCache.get(source);
+  if (hit !== void 0) {
+    fnFpCache.delete(source);
+    fnFpCache.set(source, hit);
+    return hit;
+  }
+  const fp = computeFnFingerprints(source, file);
+  if (fnFpCache.size >= MAX_FN_FP_CACHE) {
+    const oldest = fnFpCache.keys().next().value;
+    if (oldest !== void 0) fnFpCache.delete(oldest);
+  }
+  fnFpCache.set(source, fp);
+  return fp;
+}
+function generalizeSourceKeyPart(source, fnName, file) {
+  if (!file) return `w:${hashSource(source)}`;
+  const fp = fnFingerprints(source, file).get(fnName);
+  if (fp) return `f:${fp.own}:${fp.deps}`;
+  return `u:${hashSource(source)}`;
+}
+function hasAnyCallLike(node, depth = 0) {
+  if (!node || typeof node !== "object") return false;
+  if (depth > 80) return true;
+  const obj2 = node;
+  if (obj2.type === "CallExpression" || obj2.type === "NewExpression" || obj2.type === "OptionalCallExpression" || obj2.type === "ImportExpression") {
+    return true;
+  }
+  for (const key of Object.keys(obj2)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") {
+      continue;
+    }
+    const v2 = obj2[key];
+    if (Array.isArray(v2)) {
+      for (const x of v2) if (hasAnyCallLike(x, depth + 1)) return true;
+    } else if (v2 && typeof v2 === "object") {
+      if (hasAnyCallLike(v2, depth + 1)) return true;
+    }
+  }
+  return false;
+}
+function hasModuleSyntax(file) {
+  for (const stmt of file.program.body) {
+    if (stmt.type === "ImportDeclaration") return true;
+    if (stmt.type === "ExportAllDeclaration") return true;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.source) return true;
+  }
+  return false;
+}
+function canSkipLiteralCallScan(source, file) {
+  if (source.includes("@nudo:refine")) return false;
+  if (hasModuleSyntax(file)) return false;
+  if (hasAnyCallLike(file)) return false;
+  const fps = fnFingerprints(source, file);
+  for (const fp of fps.values()) {
+    if (fp.nRefs > 0) return false;
+  }
+  return true;
+}
+
+// src/algebra/load-deps-fp.ts
+var MAX_LOAD_DEP_NODES = 64;
+function normPath(p) {
+  return p.replace(/\\/g, "/");
+}
+function resolveDepPath(fromFile, spec) {
+  const s = normPath(spec);
+  if (!s.startsWith(".")) return s;
+  const from = normPath(fromFile);
+  const i = from.lastIndexOf("/");
+  const base = i >= 0 ? from.slice(0, i) : "";
+  const parts = base ? base.split("/") : [];
+  for (const seg of s.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") parts.pop();
+    else parts.push(seg);
+  }
+  return parts.join("/");
+}
+function extractAllLoadSpecs(source) {
+  const specs = /* @__PURE__ */ new Set();
+  for (const imp of extractNudoImports(source)) specs.add(imp.spec);
+  const patterns = [
+    /\bfrom\s*['"]([^'"]+)['"]/g,
+    /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+  ];
+  for (const re of patterns) {
+    let m;
+    while (m = re.exec(source)) specs.add(m[1]);
+  }
+  return [...specs];
+}
+function loadModuleDepsFingerprint(source, loadModule, fromFile) {
+  const parts = [];
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = extractAllLoadSpecs(source).map(
+    (spec) => ({ spec, from: fromFile })
+  );
+  let n = 0;
+  while (queue.length > 0) {
+    if (n >= MAX_LOAD_DEP_NODES) {
+      parts.sort();
+      return { fp: `trunc:${parts.join(",")}`, paths, truncated: true };
+    }
+    const cur = queue.shift();
+    const path = resolveDepPath(cur.from, cur.spec);
+    if (seen.has(path)) continue;
+    seen.add(path);
+    n++;
+    const src = loadModule(cur.spec, cur.from);
+    parts.push(`${path}=${src === void 0 ? "miss" : hashSource(src)}`);
+    paths.push(path);
+    if (src === void 0) continue;
+    for (const next of extractAllLoadSpecs(src)) {
+      const nextPath = resolveDepPath(path, next);
+      if (!seen.has(nextPath)) queue.push({ spec: next, from: path });
+    }
+  }
+  parts.sort();
+  return { fp: parts.join(","), paths, truncated: false };
+}
+
+// src/algebra/generalize.ts
+var generalizeMemo = /* @__PURE__ */ new Map();
+var memoKeyDeps = /* @__PURE__ */ new Map();
+var memoDepIndex = /* @__PURE__ */ new Map();
+var loadModuleIds = /* @__PURE__ */ new WeakMap();
+var nextLoadModuleId = 1;
+var MAX_GENERALIZE_MEMO = 1024;
+function resetGeneralizeMemo() {
+  generalizeMemo.clear();
+  memoKeyDeps.clear();
+  memoDepIndex.clear();
+  resetFnFpCache();
+  resetHashSourceCache();
+}
+function getGeneralizeMemoSize() {
+  return generalizeMemo.size;
+}
+function unindexMemoKey(key) {
+  const deps = memoKeyDeps.get(key);
+  if (!deps) return;
+  for (const p of deps) {
+    const set = memoDepIndex.get(p);
+    if (!set) continue;
+    set.delete(key);
+    if (set.size === 0) memoDepIndex.delete(p);
+  }
+  memoKeyDeps.delete(key);
+}
+function evictGeneralizeMemoForPaths(paths) {
+  let n = 0;
+  for (const raw of paths) {
+    const p = normPath(raw);
+    const keys = memoDepIndex.get(p);
+    if (!keys) continue;
+    for (const key of [...keys]) {
+      generalizeMemo.delete(key);
+      unindexMemoKey(key);
+      n++;
+    }
+  }
+  return n;
+}
+function loadModuleId(fn) {
+  if (!fn) return 0;
+  let id = loadModuleIds.get(fn);
+  if (id === void 0) {
+    id = nextLoadModuleId++;
+    loadModuleIds.set(fn, id);
+  }
+  return id;
+}
+function refineDepsFingerprint(source, refine) {
+  if (!refine?.loadModule || !refine.fromFile) {
+    return { fp: "-", paths: [], truncated: false };
+  }
+  return loadModuleDepsFingerprint(source, refine.loadModule, refine.fromFile);
+}
+function generalizeMemoKey(fnName, source, opts) {
+  const r = opts.refine;
+  const budget = opts.budget ?? defaultLeakBudget;
+  const deps = opts.depsFp ?? (r ? refineDepsFingerprint(source, r) : { fp: "-", paths: [], truncated: false });
+  const srcPart = generalizeSourceKeyPart(source, fnName, opts.file);
+  const key = [
+    srcPart,
+    fnName,
+    opts.label ?? "A",
+    r ? `${loadModuleId(r.loadModule)}:${r.fromFile ?? ""}` : "-",
+    deps.fp,
+    `${budget.maxDepth}/${budget.maxNodes}`
+  ].join("|");
+  return { key, depPaths: deps.paths, truncated: deps.truncated };
+}
+function generalizeMemoGet(key) {
+  if (!generalizeMemo.has(key)) return null;
+  const v2 = generalizeMemo.get(key);
+  generalizeMemo.delete(key);
+  generalizeMemo.set(key, v2);
+  return v2;
+}
+function generalizeMemoSet(key, value, depPaths) {
+  if (generalizeMemo.size >= MAX_GENERALIZE_MEMO) {
+    const oldest = generalizeMemo.keys().next().value;
+    if (oldest !== void 0) {
+      generalizeMemo.delete(oldest);
+      unindexMemoKey(oldest);
+    }
+  }
+  generalizeMemo.set(key, value);
+  if (depPaths.length > 0) {
+    memoKeyDeps.set(key, depPaths);
+    for (const p of depPaths) {
+      let set = memoDepIndex.get(p);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        memoDepIndex.set(p, set);
+      }
+      set.add(key);
+    }
+  }
+}
+function isCacheableAbs(a) {
+  return a.conf === "exact" || a.conf === "path" || a.conf === "widened" || a.conf === "mock";
+}
+function termKey(t, rename) {
+  switch (t.op) {
+    case "lit":
+      return `L:${typeof t.value}:${String(t.value)}`;
+    case "var":
+      return `V:${rename?.get(t.id) ?? t.id}`;
+    case "app":
+      return `A:${t.fn}(${t.args.map((a) => termKey(a, rename)).join(",")})`;
+  }
+}
+function predKey(p, rename) {
+  switch (p.op) {
+    case "true":
+      return "T";
+    case "false":
+      return "F";
+    case "eq":
+    case "ne":
+    case "lt":
+    case "le":
+    case "gt":
+    case "ge":
+      return `${p.op}(${termKey(p.a, rename)},${termKey(p.b, rename)})`;
+    case "and":
+    case "or": {
+      const keys = p.args.map((a) => predKey(a, rename)).sort();
+      return `${p.op}(${keys.join(",")})`;
+    }
+    case "not":
+      return `not(${predKey(p.arg, rename)})`;
+    case "typeof":
+      return `typeof(${termKey(p.t, rename)},${p.type})`;
+  }
+}
+function shapeKey(s, seen, rename) {
+  switch (s.k) {
+    case "never":
+    case "any":
+    case "unknown":
+      return s.k;
+    case "prim":
+      return `p:${s.type}`;
+    case "brand":
+      return `b:${s.name}(${absKeyInner(s.shape, seen, rename)})`;
+    case "eff":
+      return `e:${s.eff}<${absKeyInner(s.inner, seen, rename)}>`;
+    case "arr":
+      return `arr(${absKeyInner(s.element, seen, rename)})`;
+    case "tuple": {
+      const els = s.elements.map((e) => absKeyInner(e, seen, rename)).join(",");
+      const rest = s.rest ? `...${absKeyInner(s.rest, seen, rename)}` : "";
+      return `tup[${els}${rest}]`;
+    }
+    case "fn": {
+      const pts = (s.paramTypes ?? []).map((t) => absKeyInner(t, seen, rename)).join(",");
+      const ret = s.returnType ? absKeyInner(s.returnType, seen, rename) : "?";
+      const name = s.name ? `#${s.name}` : "";
+      return `fn${name}(${s.params.join(",")}|${pts})=>${ret}`;
+    }
+    case "sum":
+      return `sum(${s.members.map((m) => absKeyInner(m, seen, rename)).join("|")})`;
+    case "obj": {
+      const slots = Object.keys(s.slots).sort().map((k) => {
+        const slot = s.slots[k];
+        const flags = (slot.optional ? "?" : "") + (slot.readonly ? "r" : "");
+        return `${k}${flags}:${absKeyInner(slot.value, seen, rename)}`;
+      }).join(",");
+      const idx = s.index ? `idx(${absKeyInner(s.index.key, seen, rename)}\u2192${absKeyInner(s.index.value, seen, rename)})` : "";
+      const open = s.open ? "open" : "";
+      return `obj{${slots}}${idx}${open}`;
+    }
+  }
+}
+function absKeyInner(a, seen, rename) {
+  if (seen.has(a)) return "cycle";
+  seen.add(a);
+  const t = a.term ? `=${termKey(a.term, rename)}` : "";
+  const p = a.pred ? `@${predKey(a.pred, rename)}` : "";
+  return `${shapeKey(a.shape, seen, rename)}${t}${p}`;
+}
+function collectTermVars(t, acc) {
+  if (t.op === "var") acc.add(t.id);
+  else if (t.op === "app") for (const a of t.args) collectTermVars(a, acc);
+}
+function collectPredVars(p, acc) {
+  switch (p.op) {
+    case "true":
+    case "false":
+      return;
+    case "eq":
+    case "ne":
+    case "lt":
+    case "le":
+    case "gt":
+    case "ge":
+      collectTermVars(p.a, acc);
+      collectTermVars(p.b, acc);
+      return;
+    case "and":
+    case "or":
+      for (const a of p.args) collectPredVars(a, acc);
+      return;
+    case "not":
+      collectPredVars(p.arg, acc);
+      return;
+    case "typeof":
+      collectTermVars(p.t, acc);
+      return;
+  }
+}
+function collectAbsVars(a, acc, seen) {
+  if (seen.has(a)) return;
+  seen.add(a);
+  if (a.term) collectTermVars(a.term, acc);
+  if (a.pred) collectPredVars(a.pred, acc);
+  const s = a.shape;
+  switch (s.k) {
+    case "brand":
+      collectAbsVars(s.shape, acc, seen);
+      return;
+    case "eff":
+      collectAbsVars(s.inner, acc, seen);
+      return;
+    case "arr":
+      collectAbsVars(s.element, acc, seen);
+      return;
+    case "tuple":
+      for (const e of s.elements) collectAbsVars(e, acc, seen);
+      if (s.rest) collectAbsVars(s.rest, acc, seen);
+      return;
+    case "fn":
+      for (const t of s.paramTypes ?? []) collectAbsVars(t, acc, seen);
+      if (s.returnType) collectAbsVars(s.returnType, acc, seen);
+      return;
+    case "sum":
+      for (const m of s.members) collectAbsVars(m, acc, seen);
+      return;
+    case "obj":
+      for (const slot of Object.values(s.slots)) collectAbsVars(slot.value, acc, seen);
+      if (s.index) {
+        collectAbsVars(s.index.key, acc, seen);
+        collectAbsVars(s.index.value, acc, seen);
+      }
+      return;
+    default:
+      return;
+  }
+}
+function renameTerm(t, map) {
+  if (t.op === "var") {
+    const to = map.get(t.id);
+    return to === void 0 ? t : v(to);
+  }
+  if (t.op === "app") {
+    return { op: "app", fn: t.fn, args: t.args.map((a) => renameTerm(a, map)) };
+  }
+  return t;
+}
+function renamePred(p, map) {
+  switch (p.op) {
+    case "true":
+    case "false":
+      return p;
+    case "eq":
+    case "ne":
+    case "lt":
+    case "le":
+    case "gt":
+    case "ge":
+      return { op: p.op, a: renameTerm(p.a, map), b: renameTerm(p.b, map) };
+    case "and":
+    case "or":
+      return { op: p.op, args: p.args.map((a) => renamePred(a, map)) };
+    case "not":
+      return { op: "not", arg: renamePred(p.arg, map) };
+    case "typeof":
+      return { op: "typeof", t: renameTerm(p.t, map), type: p.type };
+  }
+}
+function renameAbs(a, map) {
+  const out = {
+    shape: renameShape(a.shape, map),
+    conf: a.conf
+  };
+  if (a.term) out.term = renameTerm(a.term, map);
+  if (a.pred) out.pred = renamePred(a.pred, map);
+  return out;
+}
+function renameShape(s, map) {
+  switch (s.k) {
+    case "never":
+    case "any":
+    case "unknown":
+    case "prim":
+      return s;
+    case "brand":
+      return { k: "brand", name: s.name, shape: renameAbs(s.shape, map) };
+    case "eff":
+      return { k: "eff", eff: s.eff, inner: renameAbs(s.inner, map) };
+    case "arr":
+      return { k: "arr", element: renameAbs(s.element, map) };
+    case "tuple": {
+      const out = {
+        k: "tuple",
+        elements: s.elements.map((e) => renameAbs(e, map))
+      };
+      if (s.rest) out.rest = renameAbs(s.rest, map);
+      return out;
+    }
+    case "fn": {
+      const out = { k: "fn", params: s.params };
+      if (s.name !== void 0) out.name = s.name;
+      if (s.paramTypes) out.paramTypes = s.paramTypes.map((t) => renameAbs(t, map));
+      if (s.returnType) out.returnType = renameAbs(s.returnType, map);
+      return out;
+    }
+    case "sum":
+      return { k: "sum", members: s.members.map((m) => renameAbs(m, map)) };
+    case "obj": {
+      const slots = {};
+      for (const [k, slot] of Object.entries(s.slots)) {
+        slots[k] = {
+          value: renameAbs(slot.value, map),
+          ...slot.optional ? { optional: true } : {},
+          ...slot.readonly ? { readonly: true } : {}
+        };
+      }
+      const out = { k: "obj", slots };
+      if (s.index) {
+        out.index = { key: renameAbs(s.index.key, map), value: renameAbs(s.index.value, map) };
+      }
+      if (s.open) out.open = true;
+      return out;
+    }
+  }
+}
+function instantiateMemoKey(args, phi) {
+  const acc = /* @__PURE__ */ new Set();
+  for (const a of args) collectAbsVars(a, acc, /* @__PURE__ */ new Set());
+  collectPredVars(phi, acc);
+  const varOrder = [...acc].sort();
+  const rename = new Map(varOrder.map((id, i) => [id, `\u03B1${i}`]));
+  const key = `${args.map((a) => absKeyInner(a, /* @__PURE__ */ new Set(), rename)).join(";")}#${predKey(phi, rename)}`;
+  return { key, varOrder };
+}
+function alphaRenameResult(result, fromOrder, toOrder) {
+  if (fromOrder.length !== toOrder.length) return result;
+  let same = true;
+  for (let i = 0; i < fromOrder.length; i++) {
+    if (fromOrder[i] !== toOrder[i]) {
+      same = false;
+      break;
+    }
+  }
+  if (same) return result;
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < fromOrder.length; i++) {
+    map.set(fromOrder[i], toOrder[i]);
+  }
+  return renameAbs(result, map);
+}
+function extractFn(source, fnName, fileAst) {
+  const file = fileAst ?? parseSource(source);
+  const env = emptyEnv();
+  for (const stmt of file.program.body) {
+    let decl = stmt;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      env.fns.set(decl.id.name, {
+        params: decl.params.map((p) => p.type === "Identifier" ? p.name : "_"),
+        body: decl.body,
+        async: decl.async === true
+      });
+    }
+    if (decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        if (d.id.type === "Identifier" && d.init && (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")) {
+          const init = d.init;
+          env.fns.set(d.id.name, {
+            params: init.params.map(
+              (p) => p.type === "Identifier" ? p.name ?? "_" : "_"
+            ),
+            body: init.body,
+            async: init.async === true
+          });
+        }
+      }
+    }
+  }
+  const fn = env.fns.get(fnName);
+  if (!fn) return void 0;
+  return { params: fn.params, body: fn.body, env };
+}
+function generalizeFromAst(fnName, source, opts = {}) {
+  const { key, depPaths, truncated } = generalizeMemoKey(fnName, source, opts);
+  if (!truncated) {
+    const cached = generalizeMemoGet(key);
+    if (cached !== null) {
+      return cached;
+    }
+  }
+  const result = generalizeFromAstUncached(fnName, source, opts);
+  if (!truncated) {
+    generalizeMemoSet(key, result, depPaths);
+  }
+  return result;
+}
+function generalizeFromAstUncached(fnName, source, opts = {}) {
+  const extracted = extractFn(source, fnName, opts.file);
+  if (!extracted) return void 0;
+  const { params, body, env } = extracted;
+  const budget = opts.budget ?? defaultLeakBudget;
+  const label = opts.label ?? "A";
+  const typeParams = params.map((p, i) => ({
+    id: `${label}${i + 1}`,
+    // 无约束参数 = any（任意 JS 值），不是 unknown（分析无信息）
+    value: abs({ k: "any" }, v(`${label}${i + 1}`), pTrue, "path")
+  }));
+  let entryReqs;
+  const refineEntryShapes = /* @__PURE__ */ new Map();
+  if (opts.refine) {
+    try {
+      const reqs = extractRefinesFromSource(source, fnName, opts.refine);
+      if (reqs.length > 0) {
+        entryReqs = reqs.map((r) => ({ param: r.param, pred: r.pred }));
+        for (const r of reqs) {
+          const idx = params.indexOf(r.param);
+          if (idx >= 0) {
+            const entryAbs = constraintToEntryAbs(r.constraint, r.param);
+            typeParams[idx] = {
+              id: typeParams[idx].id,
+              value: entryAbs
+            };
+            refineEntryShapes.set(r.param, {
+              abs: snapshotAbs(entryAbs),
+              source: "refine"
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const instMemo = /* @__PURE__ */ new Map();
+  const paramNames = new Set(params);
+  const alphaIds = typeParams.map((t) => t.id);
+  const run = (args, phi = pTrue, collector) => {
+    const { key, varOrder } = instantiateMemoKey(args, phi);
+    const hit = instMemo.get(key);
+    if (hit !== void 0) {
+      return alphaRenameResult(hit.result, hit.varOrder, varOrder);
+    }
+    const hc = collector ?? createHofCollectCtx(paramNames, alphaIds);
+    const local = {
+      vars: new Map(env.vars),
+      fns: env.fns,
+      hofCollect: hc
+    };
+    params.forEach((p, i) => {
+      local.vars.set(p, args[i] ?? unknown);
+    });
+    const result = evalNode(body, local, phi, budget).value;
+    if (isCacheableAbs(result)) {
+      instMemo.set(key, { result, varOrder });
+    }
+    return result;
+  };
+  const hofCollector = createHofCollectCtx(paramNames, alphaIds);
+  const symbolic = run(
+    typeParams.map((t) => t.value),
+    // 入口契约进 Φ，让 body 内的单调性可传播
+    entryReqs && entryReqs.length > 0 ? entryReqs.length === 1 ? entryReqs[0].pred : { op: "and", args: entryReqs.map((r) => r.pred) } : pTrue,
+    hofCollector
+  );
+  let fnRels;
+  let entryShapes;
+  let hofSites;
+  if (symbolic.conf !== "opaque") {
+    if (refineEntryShapes.size > 0) {
+      entryShapes = new Map(refineEntryShapes);
+      for (const [param, rec] of refineEntryShapes) {
+        if (rec.abs.shape.k !== "fn") continue;
+        if (!fnRels) fnRels = /* @__PURE__ */ new Map();
+        fnRels.set(param, { abs: snapshotAbs(rec.abs), source: rec.source });
+      }
+    }
+    for (const [param, rec] of hofCollector.fnRels) {
+      if (refineEntryShapes.has(param)) continue;
+      if (!fnRels) fnRels = /* @__PURE__ */ new Map();
+      fnRels.set(param, { abs: snapshotAbs(rec.abs), source: rec.source });
+    }
+    for (const [param, rec] of hofCollector.entryShapes) {
+      if (refineEntryShapes.has(param)) continue;
+      if (!entryShapes) entryShapes = /* @__PURE__ */ new Map();
+      entryShapes.set(param, { abs: snapshotAbs(rec.abs), source: rec.source });
+    }
+    if (hofCollector.sites.length > 0) {
+      hofSites = hofCollector.sites.map((s) => ({
+        ...s,
+        argTerms: [...s.argTerms],
+        result: snapshotAbs(s.result)
+      }));
+    }
+  }
+  return {
+    name: fnName,
+    params,
+    typeParams,
+    symbolic,
+    instantiate: (args, phi) => run(args, phi ?? pTrue),
+    display: formatPoly(
+      fnName,
+      params,
+      typeParams,
+      symbolic,
+      entryReqs,
+      entryShapes,
+      fnRels
+    ),
+    ...entryReqs ? { entryReqs } : {},
+    ...fnRels ? { fnRels } : {},
+    ...entryShapes ? { entryShapes } : {},
+    ...hofSites ? { hofSites } : {}
+  };
+}
+function formatPoly(name, params, typeParams, symbolic, entryReqs, entryShapes, fnRels) {
+  const reqByParam = new Map((entryReqs ?? []).map((r) => [r.param, r.pred]));
+  const ps = params.map((p, i) => {
+    const id = typeParams[i]?.id ?? "unknown";
+    const pred = reqByParam.get(p);
+    const promoted = entryShapes?.get(p)?.abs ?? fnRels?.get(p)?.abs;
+    if (promoted) {
+      const slot = formatShapeSlot(promoted);
+      if (pred && pred.op !== "true") {
+        return `${p}: ${slot} where ${predToString(pred)}`;
+      }
+      return `${p}: ${slot}`;
+    }
+    if (pred && pred.op !== "true") {
+      return `${p}: ${id} where ${predToString(pred)}`;
+    }
+    return `${p}: ${id}`;
+  }).join(", ");
+  const ret = formatShapeSlot(symbolic);
+  const termPart = symbolic.term && symbolic.term.op !== "lit" ? ` = ${termToString(symbolic.term)}` : "";
+  const predPart = symbolic.pred && symbolic.pred.op !== "true" ? `  where ${predToString(symbolic.pred)}` : "";
+  return `${name}: (${ps}) => ${ret}${termPart}${predPart}`;
+}
+function generalizeAll(source, opts = {}) {
+  const file = parseSource(source);
+  const names = [];
+  for (const stmt of file.program.body) {
+    if (stmt.type === "FunctionDeclaration" && stmt.id) names.push(stmt.id.name);
+    if (stmt.type === "VariableDeclaration") {
+      for (const d of stmt.declarations) {
+        if (d.id.type === "Identifier" && d.init && (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")) {
+          names.push(d.id.name);
+        }
+      }
+    }
+  }
+  const out = [];
+  for (const n of names) {
+    const g = generalizeFromAst(n, source, opts);
+    if (g) out.push(g);
+  }
+  return out;
+}
+function listFunctionNames(source) {
+  const file = parseSource(source);
+  const names = [];
+  for (const stmt of file.program.body) {
+    if (stmt.type === "FunctionDeclaration" && stmt.id) names.push(stmt.id.name);
+    if (stmt.type === "VariableDeclaration") {
+      for (const d of stmt.declarations) {
+        if (d.id.type === "Identifier" && d.init && (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")) {
+          names.push(d.id.name);
+        }
+      }
+    }
+  }
+  return names;
+}
+function buildArgsFromAssume(source, fnName, assumeIds) {
+  const extracted = extractFn(source, fnName);
+  if (!extracted) return [];
+  return extracted.params.map((p) => {
+    if (assumeIds.has(p)) {
+      return abs(
+        { k: "prim", type: "number" },
+        v(p),
+        { op: "gt", a: v(p), b: { op: "lit", value: 0 } },
+        "path"
+      );
+    }
+    return abs({ k: "unknown" }, void 0, void 0, "partial");
+  });
+}
+
+// src/algebra/diagnostics.ts
+function checkArg(arg, expect, phi = pTrue) {
+  if (!expect || expect.op === "true") return void 0;
+  if (arg.shape.k === "unknown" && !arg.term) {
+    return {
+      severity: "warning",
+      code: "nudo:arg-opaque",
+      message: `\u5B9E\u53C2\u7C7B\u578B unknown\uFF0C\u65E0\u6CD5\u9A8C\u8BC1\u7EA6\u675F ${predToString(expect)}`,
+      suggestion: "\u8865\u5145\u8C03\u7528\u70B9\u3001@nudo:case\uFF0C\u6216 --assume \u63D0\u4F9B\u524D\u7F6E\u6761\u4EF6"
+    };
+  }
+  const combined = arg.pred && arg.pred.op !== "true" ? phi.op === "true" ? arg.pred : { op: "and", args: [phi, arg.pred] } : phi;
+  if (implies(combined, expect)) return void 0;
+  const lv = litValue(arg);
+  if (lv !== void 0 && (expect.op === "gt" || expect.op === "ge" || expect.op === "lt" || expect.op === "le")) {
+    const ok = decideLitCmp(lv, expect);
+    if (ok === true) return void 0;
+    if (ok === false) {
+      return {
+        severity: "error",
+        code: "nudo:constraint-violated",
+        message: `\u5B9E\u53C2 ${JSON.stringify(lv)} \u4E0D\u6EE1\u8DB3 ${predToString(expect)}`,
+        suggestion: `\u6539\u7528\u6EE1\u8DB3\u7EA6\u675F\u7684\u503C\uFF0C\u6216\u653E\u5BBD\u51FD\u6570\u524D\u7F6E\u6761\u4EF6`
+      };
+    }
+  }
+  return {
+    severity: "warning",
+    code: "nudo:constraint-unproven",
+    message: `\u65E0\u6CD5\u8BC1\u660E\u5B9E\u53C2\u6EE1\u8DB3 ${predToString(expect)}`,
+    suggestion: `\u5DF2\u77E5\u4FE1\u606F\u4E0D\u8DB3\uFF1B\u53EF --assume \u6216\u8865 case`
+  };
+}
+function decideLitCmp(lv, p) {
+  if (typeof lv !== "number" || p.b.op !== "lit" || typeof p.b.value !== "number") {
+    return void 0;
+  }
+  const n = p.b.value;
+  switch (p.op) {
+    case "gt":
+      return lv > n;
+    case "ge":
+      return lv >= n;
+    case "lt":
+      return lv < n;
+    case "le":
+      return lv <= n;
+    default:
+      return void 0;
+  }
+}
+function checkCall(source, fnName, args, phi = pTrue) {
+  const diags = [];
+  const g = generalizeFromAst(fnName, source);
+  if (!g) {
+    diags.push({
+      severity: "error",
+      code: "nudo:fn-not-found",
+      message: `\u672A\u627E\u5230\u51FD\u6570 ${fnName}`
+    });
+    return diags;
+  }
+  if (args.length !== g.params.length) {
+    diags.push({
+      severity: "error",
+      code: "nudo:arg-count",
+      message: `${fnName} \u671F\u671B ${g.params.length} \u4E2A\u53C2\u6570\uFF0C\u5B9E\u9645 ${args.length}`,
+      fn: fnName
+    });
+    return diags;
+  }
+  const required = extractParamRequirements(g);
+  args.forEach((arg, i) => {
+    const req = required.get(i);
+    const d = checkArg(arg, req, phi);
+    if (d) diags.push({ ...d, fn: fnName, argIndex: i });
+  });
+  try {
+    const result = analyzeFn(source, fnName, args, phi);
+    if (result.conf === "partial" || result.conf === "opaque") {
+      diags.push({
+        severity: "info",
+        code: "nudo:partial-result",
+        message: `${fnName}(...) \u7ED3\u679C\u7F6E\u4FE1\u5EA6 ${result.conf}`,
+        suggestion: "\u8865\u5145\u8C03\u7528\u70B9\u6216\u7EA6\u675F\u53EF\u63D0\u9AD8\u7CBE\u5EA6",
+        fn: fnName
+      });
+    }
+  } catch (e) {
+    diags.push({
+      severity: "error",
+      code: "nudo:eval-error",
+      message: `\u6C42\u503C\u5931\u8D25: ${e.message}`,
+      fn: fnName
+    });
+  }
+  return diags;
+}
+function extractParamRequirements(g) {
+  const map = /* @__PURE__ */ new Map();
+  const pred = g.symbolic.pred;
+  if (!pred || pred.op === "true") return map;
+  const paramIndex = /* @__PURE__ */ new Map();
+  g.typeParams.forEach((t, i) => paramIndex.set(t.id, i));
+  const consider = (p) => {
+    if (p.op === "and") {
+      p.args.forEach(consider);
+      return;
+    }
+    if ((p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") && p.a.op === "var" && paramIndex.has(p.a.id) && p.b.op === "lit") {
+      map.set(paramIndex.get(p.a.id), p);
+    }
+  };
+  consider(pred);
+  return map;
+}
+function formatDiagnostics(diags) {
+  if (diags.length === 0) return "No issues found.";
+  return diags.map((d) => {
+    const loc = d.fn ? `${d.fn}${d.argIndex !== void 0 ? `[${d.argIndex}]` : ""}: ` : "";
+    let s = `[${d.severity}] ${loc}${d.message} (${d.code})`;
+    if (d.suggestion) s += `
+    \u2192 ${d.suggestion}`;
+    return s;
+  }).join("\n");
+}
+
+// src/algebra/stable-source-key.ts
+function stableAnalyzeKeySource(source) {
+  let end = source.length;
+  while (end > 0) {
+    const ch = source.charCodeAt(end - 1);
+    if (ch === 10 || ch === 13 || ch === 32 || ch === 9) {
+      end--;
+      continue;
+    }
+    break;
+  }
+  const lineStart = source.lastIndexOf("\n", end - 1) + 1;
+  const lastLine = source.slice(lineStart, end);
+  const trimmedLast = lastLine.trim();
+  if (trimmedLast !== "" && !trimmedLast.startsWith("//") && !trimmedLast.startsWith("/*")) {
+    let body2 = source.slice(0, end);
+    if (body2.endsWith("*/")) {
+      body2 = stripTrailingBlockComments(body2);
+      return body2 + "\n";
+    }
+    const after = source.slice(end);
+    if (after === "" || after === "\n") return source;
+    return source.slice(0, end) + "\n";
+  }
+  const lines = source.split("\n");
+  while (lines.length > 0) {
+    const last = lines[lines.length - 1];
+    if (last.trim() === "") {
+      lines.pop();
+      continue;
+    }
+    if (last.trimStart().startsWith("//") && !last.includes("@nudo")) {
+      lines.pop();
+      continue;
+    }
+    if (last.trim() === "*/" || last.trimStart().startsWith("/*")) {
+      const joined = stripTrailingBlockComments(lines.join("\n"));
+      const stripped = joined.split("\n");
+      if (stripped.length < lines.length) {
+        lines.length = 0;
+        lines.push(...stripped);
+        continue;
+      }
+    }
+    break;
+  }
+  let body = lines.join("\n").replace(/\s+$/, "");
+  body = stripTrailingBlockComments(body);
+  return body + "\n";
+}
+function stripTrailingBlockComments(body) {
+  let t = body.replace(/\s+$/, "");
+  while (t.endsWith("*/")) {
+    const start = t.lastIndexOf("/*");
+    if (start < 0) break;
+    const block = t.slice(start);
+    if (block.includes("@nudo")) break;
+    const before = t.slice(0, start);
+    const lineStart = before.lastIndexOf("\n") + 1;
+    if (before.slice(lineStart).trim() !== "") break;
+    t = before.replace(/\s+$/, "");
+  }
+  return t;
+}
+
+// src/algebra/check.ts
+function hofFnArgOk(src, tgt) {
+  if (src.shape.k !== "fn") return false;
+  const t = tgt.shape;
+  if (t.k !== "fn") return false;
+  if (src.shape.params.length < t.params.length) return false;
+  return true;
+}
+var checkReportMemo = /* @__PURE__ */ new Map();
+var checkKeyDeps = /* @__PURE__ */ new Map();
+var checkDepIndex = /* @__PURE__ */ new Map();
+var loadModuleIds2 = /* @__PURE__ */ new WeakMap();
+var nextLoadModuleId2 = 1;
+var MAX_CHECK_MEMO = 256;
+function resetCheckSourceMemo() {
+  checkReportMemo.clear();
+  checkKeyDeps.clear();
+  checkDepIndex.clear();
+  resetHashSourceCache();
+}
+function getCheckSourceMemoSize() {
+  return checkReportMemo.size;
+}
+function loadModuleId2(fn) {
+  if (!fn) return 0;
+  let id = loadModuleIds2.get(fn);
+  if (id === void 0) {
+    id = nextLoadModuleId2++;
+    loadModuleIds2.set(fn, id);
+  }
+  return id;
+}
+function checkDepsFingerprint(source, opts) {
+  if (!opts.loadModule || !opts.fromFile) {
+    return { fp: "-", paths: [], truncated: false };
+  }
+  return loadModuleDepsFingerprint(source, opts.loadModule, opts.fromFile);
+}
+function unindexCheckKey(key) {
+  const deps = checkKeyDeps.get(key);
+  if (!deps) return;
+  for (const p of deps) {
+    const set = checkDepIndex.get(p);
+    if (!set) continue;
+    set.delete(key);
+    if (set.size === 0) checkDepIndex.delete(p);
+  }
+  checkKeyDeps.delete(key);
+}
+function evictCheckSourceMemoForPaths(paths) {
+  let n = 0;
+  for (const raw of paths) {
+    const p = normPath(raw);
+    const keys = checkDepIndex.get(p);
+    if (!keys) continue;
+    for (const key of [...keys]) {
+      checkReportMemo.delete(key);
+      unindexCheckKey(key);
+      n++;
+    }
+  }
+  return n;
+}
+function cloneCheckReport(r) {
+  return {
+    file: r.file,
+    issues: r.issues.map((i) => ({ ...i })),
+    ok: r.ok,
+    signatures: r.signatures.map((s) => ({
+      ...s,
+      params: [...s.params]
+    })),
+    summary: { ...r.summary }
+  };
+}
+function checkMemoKey(filePath, source, identityOpts, deps) {
+  return [
+    hashSource(source),
+    filePath,
+    `${loadModuleId2(identityOpts.loadModule)}:${identityOpts.fromFile ?? ""}`,
+    deps.fp
+  ].join("|");
+}
+function checkMemoGet(key) {
+  if (!checkReportMemo.has(key)) return null;
+  const v2 = checkReportMemo.get(key);
+  checkReportMemo.delete(key);
+  checkReportMemo.set(key, v2);
+  return v2;
+}
+function checkMemoSet(key, value, depPaths) {
+  if (checkReportMemo.size >= MAX_CHECK_MEMO) {
+    const oldest = checkReportMemo.keys().next().value;
+    if (oldest !== void 0) {
+      checkReportMemo.delete(oldest);
+      unindexCheckKey(oldest);
+    }
+  }
+  checkReportMemo.set(key, value);
+  if (depPaths.length > 0) {
+    checkKeyDeps.set(key, depPaths);
+    for (const p of depPaths) {
+      let set = checkDepIndex.get(p);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        checkDepIndex.set(p, set);
+      }
+      set.add(key);
+    }
+  }
+}
+function listTopFunctions(source, file) {
+  const f = file ?? parseSource(source);
+  const names = [];
+  for (const stmt of f.program.body) {
+    let decl = stmt;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (decl.type === "FunctionDeclaration" && decl.id) names.push(decl.id.name);
+    if (decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        if (d.id.type === "Identifier" && d.init && (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")) {
+          names.push(d.id.name);
+        }
+      }
+    }
+  }
+  return names;
+}
+function checkSource(filePath, source, phi = pTrue, opts = {}) {
+  let callOpts = opts;
+  if (opts.loadModule && opts.fromFile) {
+    const loadCache = /* @__PURE__ */ new Map();
+    const raw = opts.loadModule;
+    const fromFile = opts.fromFile;
+    callOpts = {
+      ...opts,
+      loadModule: (spec, from) => {
+        const k = `${from}\0${spec}`;
+        if (!loadCache.has(k)) loadCache.set(k, raw(spec, from));
+        return loadCache.get(k);
+      }
+    };
+  }
+  const useMemo = phi.op === "true";
+  let memoKey;
+  const stable = stableAnalyzeKeySource(source);
+  const depsFp = checkDepsFingerprint(stable, callOpts);
+  const allowMemo = useMemo && !depsFp.truncated;
+  if (allowMemo) {
+    memoKey = checkMemoKey(filePath, stable, opts, depsFp);
+    const hit = checkMemoGet(memoKey);
+    if (hit) return cloneCheckReport(hit);
+  }
+  const issues = [];
+  const signatures = [];
+  const file = parseSource(source);
+  const names = listTopFunctions(source, file);
+  const truncated = /* @__PURE__ */ new Set();
+  resetAbsCallBudget();
+  setAbsTruncationCollector((label) => truncated.add(label));
+  try {
+    const report = checkSourceInner(
+      filePath,
+      source,
+      file,
+      phi,
+      callOpts,
+      issues,
+      signatures,
+      names,
+      truncated,
+      opts,
+      depsFp
+    );
+    if (memoKey) checkMemoSet(memoKey, report, depsFp.paths);
+    return cloneCheckReport(report);
+  } finally {
+    setAbsTruncationCollector(null);
+  }
+}
+function checkSourceInner(filePath, source, file, phi, opts, issues, signatures, names, truncated, identityOpts = opts, depsFp) {
+  const hasRefineDirective = source.includes("@nudo:refine");
+  const refineLoad = identityOpts.loadModule ?? opts.loadModule;
+  const refineFrom = identityOpts.fromFile ?? opts.fromFile ?? filePath;
+  for (const name of names) {
+    const g = generalizeFromAst(name, source, {
+      file,
+      refine: {
+        loadModule: refineLoad,
+        fromFile: refineFrom
+      },
+      depsFp
+    });
+    if (!g) {
+      issues.push({
+        severity: "warning",
+        code: "nudo:no-signature",
+        message: `${name}: \u65E0\u6CD5\u5F52\u7EB3\u7B26\u53F7 Abs`,
+        suggestion: "\u8865 @nudo:case \u6216\u8BA9\u51FD\u6570\u4F53\u53EF\u4EE3\u6570\u6C42\u503C",
+        fn: name
+      });
+      continue;
+    }
+    const fmt = formatSigCached(g.symbolic, name);
+    signatures.push({
+      name,
+      params: g.params,
+      abs: g.symbolic,
+      display: fmt.display,
+      detail: fmt.detail,
+      conf: g.symbolic.conf
+    });
+    if (hasRefineDirective) {
+      const ret = extractRefineReturnFromSource(source, name, {
+        loadModule: refineLoad,
+        fromFile: refineFrom
+      });
+      if (ret) {
+        issues.push(
+          ...checkReturnConstraint(name, ret.name, ret.constraint, g.symbolic)
+        );
+      }
+    }
+    if (g.symbolic.conf === "opaque" || g.symbolic.conf === "partial") {
+      const entryArgs = g.typeParams.map((t) => t.value);
+      try {
+        const r = analyzeFn(source, name, entryArgs, phi, void 0, file);
+        if (r.conf === "opaque" && !truncated.has(name)) {
+          issues.push({
+            severity: "info",
+            code: "nudo:opaque-result",
+            message: `${name}(...): conf=opaque\uFF08\u8DEF\u5F84\u672A\u8986\u76D6\u6216 native\uFF09`,
+            suggestion: "\u8865 @nudo:case \u6216\u8C03\u7528\u70B9",
+            fn: name
+          });
+        }
+      } catch (e) {
+        issues.push({
+          severity: "error",
+          code: "nudo:eval-error",
+          message: `${name}: \u6C42\u503C\u5931\u8D25 \u2014 ${e.message}`,
+          fn: name
+        });
+      }
+    }
+  }
+  for (const label of truncated) {
+    issues.push({
+      severity: "warning",
+      code: "nudo:recursion-truncated",
+      message: `Recursive evaluation of '${label}' was truncated (depth/size budget); result widened to unknown`,
+      suggestion: "\u6536\u7A84\u9012\u5F52\u57FA\u4F8B\u6216\u6539\u7528\u663E\u5F0F @nudo:refine return \u5951\u7EA6",
+      fn: label
+    });
+  }
+  const records = [];
+  const varAbs = /* @__PURE__ */ new Map();
+  setAbsAssignCollector((r) => records.push(r));
+  try {
+    const { env } = evalProgramAbs(source, { file });
+    for (const [k, v2] of env.vars) varAbs.set(k, v2);
+  } catch {
+  } finally {
+    setAbsAssignCollector(null);
+  }
+  const callIssues = canSkipLiteralCallScan(source, file) ? [] : scanLiteralCalls(source, names, phi, {
+    loadModule: opts.loadModule,
+    fromFile: filePath,
+    file,
+    varAbs
+  });
+  issues.push(...callIssues);
+  issues.push(
+    ...scanCaseInconsistency(source, names, {
+      loadModule: opts.loadModule,
+      fromFile: filePath,
+      file
+    })
+  );
+  issues.push(...structuralAssignIssues(records));
+  const errors = issues.filter((i) => i.severity === "error").length;
+  const warnings = issues.filter((i) => i.severity === "warning").length;
+  const infos = issues.filter((i) => i.severity === "info").length;
+  return {
+    file: filePath,
+    issues,
+    ok: errors === 0,
+    signatures,
+    summary: { errors, warnings, infos, functions: signatures.length }
+  };
+}
+function absUnknown() {
+  return { shape: { k: "unknown" }, conf: "partial" };
+}
+var sigFormatCache = /* @__PURE__ */ new WeakMap();
+function formatSigCached(absVal, name) {
+  const hit = sigFormatCache.get(absVal);
+  if (hit) return hit;
+  const out = {
+    display: formatAbs(absVal),
+    detail: formatAbsMultiline(absVal, name)
+  };
+  sigFormatCache.set(absVal, out);
+  return out;
+}
+function checkReturnConstraint(fnName, cName, constraint, ret) {
+  const out = [];
+  if (ret.shape.k === "unknown" && !ret.term) return out;
+  if (ret.shape.k === "any") return out;
+  const push = (actual, expected, suggestion) => {
+    out.push({
+      severity: "error",
+      code: "nudo:constraint-violated",
+      message: `${fnName}: \u8FD4\u56DE\u503C \u22AD @nudo:refine return ${cName}`,
+      actual,
+      expected,
+      suggestion,
+      fn: fnName
+    });
+  };
+  if (constraint.fields) {
+    const slots = ret.shape.k === "obj" ? ret.shape.slots : void 0;
+    if (!slots) {
+      if (ret.shape.k !== "never") {
+        push(formatAbs(ret), `object shape (${cName})`, `\u8FD4\u56DE\u6EE1\u8DB3 ${cName} \u5F62\u72B6\u7684 object`);
+      }
+      return out;
+    }
+    for (const [key, field] of Object.entries(constraint.fields)) {
+      const slot = slots[key];
+      if (!slot) {
+        if (!field.optional && !field.constraint.isOptional) {
+          push(formatAbs(ret), `missing field ${key}`, `\u8FD4\u56DE\u503C\u8865\u5168\u5B57\u6BB5 ${key}`);
+        }
+        continue;
+      }
+      if (field.constraint.prim && slot.value.shape.k === "prim") {
+        const actualPrim = slot.value.shape.type;
+        if (actualPrim !== field.constraint.prim) {
+          push(
+            formatAbs(slot.value),
+            `typeof ${key} = "${field.constraint.prim}"`,
+            `\u628A\u8FD4\u56DE\u503C\u7684 ${key} \u6539\u6210 ${field.constraint.prim}`
+          );
+          continue;
+        }
+      }
+      const lv2 = litValue(slot.value);
+      if (lv2 !== void 0 && typeof lv2 === "number") {
+        for (const p of field.constraint.preds) {
+          const flat = p.op === "and" ? p.args : [p];
+          for (const atom of flat) {
+            if ((atom.op === "gt" || atom.op === "ge" || atom.op === "lt" || atom.op === "le") && atom.b.op === "lit" && typeof atom.b.value === "number") {
+              const n = atom.b.value;
+              let ok = true;
+              if (atom.op === "gt") ok = lv2 > n;
+              if (atom.op === "ge") ok = lv2 >= n;
+              if (atom.op === "lt") ok = lv2 < n;
+              if (atom.op === "le") ok = lv2 <= n;
+              if (!ok) {
+                const opSym = { gt: ">", ge: "\u2265", lt: "<", le: "\u2264" }[atom.op];
+                push(
+                  formatAbs(slot.value),
+                  `${key} ${opSym} ${n}`,
+                  `\u8FD4\u56DE\u503C\u7684 ${key} \u5E94\u6EE1\u8DB3 ${key} ${opSym} ${n}`
+                );
+              }
+            }
+          }
+        }
+      }
+    }
+    return out;
+  }
+  if (constraint.prim && ret.shape.k === "prim") {
+    const actualPrim = ret.shape.type;
+    if (actualPrim !== constraint.prim) {
+      push(formatAbs(ret), `typeof return = "${constraint.prim}"`, `\u8FD4\u56DE ${constraint.prim}`);
+      return out;
+    }
+  }
+  const lv = litValue(ret);
+  if (lv !== void 0 && typeof lv === "number") {
+    for (const p of constraint.preds) {
+      const flat = p.op === "and" ? p.args : [p];
+      for (const atom of flat) {
+        if ((atom.op === "gt" || atom.op === "ge" || atom.op === "lt" || atom.op === "le") && atom.b.op === "lit" && typeof atom.b.value === "number") {
+          const n = atom.b.value;
+          let ok = true;
+          if (atom.op === "gt") ok = lv > n;
+          if (atom.op === "ge") ok = lv >= n;
+          if (atom.op === "lt") ok = lv < n;
+          if (atom.op === "le") ok = lv <= n;
+          if (!ok) {
+            const opSym = { gt: ">", ge: "\u2265", lt: "<", le: "\u2264" }[atom.op];
+            push(formatAbs(ret), `return ${opSym} ${n}`, `\u8FD4\u56DE\u6EE1\u8DB3 ${opSym} ${n} \u7684\u503C`);
+          }
+        }
+      }
+    }
+  }
+  return out;
+}
+function structuralAssignIssues(records) {
+  const out = [];
+  for (const r of records) {
+    if (!r.prev) continue;
+    if (r.next.shape.k === "unknown" && !r.next.term) continue;
+    if (r.prev.shape.k === "unknown" && !r.prev.term) continue;
+    const leq = leqAbs(r.next, r.prev);
+    if (!leq.ok) {
+      out.push({
+        severity: "error",
+        code: "nudo:assign-mismatch",
+        message: `${r.name}: \u8D4B\u503C \u22AD \u539F\u6709\u5F62\u72B6`,
+        actual: formatAbs(r.next),
+        expected: formatAbs(r.prev),
+        suggestion: leq.reason ?? "\u6539\u7528\u517C\u5BB9\u7684\u503C\uFF0C\u6216\u653E\u5BBD\u7ED1\u5B9A\u7C7B\u578B",
+        fn: r.name,
+        line: r.line,
+        column: r.column
+      });
+    }
+  }
+  return out;
+}
+function scanCaseInconsistency(source, knownFns, opts) {
+  const out = [];
+  if (!source.includes("@nudo:case")) return out;
+  if (!source.includes("@nudo:refine")) return out;
+  const file = opts.file ?? parseSource(source);
+  const parseLitArg = (s) => {
+    const t = s.trim();
+    if (t === "") return void 0;
+    if (t === "true") return { shape: { k: "prim", type: "boolean" }, term: { op: "lit", value: true }, conf: "exact" };
+    if (t === "false") return { shape: { k: "prim", type: "boolean" }, term: { op: "lit", value: false }, conf: "exact" };
+    if (t === "null") return { shape: { k: "unknown" }, term: { op: "lit", value: null }, conf: "exact" };
+    if (t === "undefined") return { shape: { k: "unknown" }, term: { op: "lit", value: void 0 }, conf: "exact" };
+    if (/^-?\d+(\.\d+)?$/.test(t)) return numLit(Number(t));
+    const str2 = t.match(/^(['"])([\s\S]*)\1$/);
+    if (str2) {
+      return {
+        shape: { k: "prim", type: "string" },
+        term: { op: "lit", value: str2[2] },
+        conf: "exact"
+      };
+    }
+    return void 0;
+  };
+  const parseCaseArgs = (raw) => {
+    const m = raw.match(/@nudo:case\s+"[^"]+"\s*\(([\s\S]*)\)/);
+    if (!m) return void 0;
+    const inner = m[1].trim();
+    if (inner === "") return [];
+    const parts = [];
+    let depth = 0;
+    let cur = "";
+    let quote = null;
+    for (let i = 0; i < inner.length; i++) {
+      const ch = inner[i];
+      if (quote) {
+        cur += ch;
+        if (ch === quote && inner[i - 1] !== "\\") quote = null;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        quote = ch;
+        cur += ch;
+        continue;
+      }
+      if (ch === "(" || ch === "[" || ch === "{") depth++;
+      if (ch === ")" || ch === "]" || ch === "}") depth--;
+      if (ch === "," && depth === 0) {
+        parts.push(cur);
+        cur = "";
+        continue;
+      }
+      cur += ch;
+    }
+    if (cur.trim()) parts.push(cur);
+    return parts;
+  };
+  const checkCaseAgainstReqs = (fnName, caseName, args, line) => {
+    const g = generalizeFromAst(fnName, source, file ? { file } : {});
+    if (!g) return;
+    const paramNames = g.params;
+    const reqs = refineToIndexedFull(source, fnName, paramNames, {
+      loadModule: opts.loadModule,
+      fromFile: opts.fromFile ?? ""
+    });
+    if (reqs.length === 0) return;
+    const absArgs = args.map((a) => parseLitArg(a) ?? absUnknown());
+    for (const [idx, entry] of reqs) {
+      if (entry.constraint.fields) continue;
+      const arg = absArgs[idx];
+      if (!arg) continue;
+      const lv = litValue(arg);
+      if (lv === void 0 || typeof lv !== "number") continue;
+      const flatten = (p) => p.op === "and" ? p.args.flatMap(flatten) : p.op === "true" ? [] : [p];
+      for (const p of flatten(entry.pred)) {
+        if ((p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") && p.b.op === "lit" && typeof p.b.value === "number") {
+          const n = p.b.value;
+          let ok = true;
+          if (p.op === "gt") ok = lv > n;
+          if (p.op === "ge") ok = lv >= n;
+          if (p.op === "lt") ok = lv < n;
+          if (p.op === "le") ok = lv <= n;
+          if (!ok) {
+            const paramName = entry.param || paramNames[idx] || `arg${idx}`;
+            out.push({
+              severity: "error",
+              code: "nudo:case-inconsistency",
+              message: `${fnName} case "${caseName}": \u89C1\u8BC1 \u22AD \u5951\u7EA6`,
+              actual: formatAbs(arg),
+              expected: predToString(p),
+              suggestion: `\u6539 case \u5B9E\u53C2\uFF0C\u6216\u653E\u5BBD ${paramName} \u7684 refine`,
+              fn: fnName,
+              line
+            });
+          }
+        }
+      }
+    }
+  };
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj2 = n;
+    let decl = obj2;
+    if (obj2.type === "ExportNamedDeclaration" || obj2.type === "ExportDefaultDeclaration") {
+      decl = obj2.declaration;
+    }
+    if (decl && (decl.type === "FunctionDeclaration" || decl.type === "VariableDeclaration" && (decl.declarations ?? [])[0]?.init && ["ArrowFunctionExpression", "FunctionExpression"].includes(
+      String(
+        decl.declarations[0].init.type
+      )
+    ))) {
+      const id = decl.type === "FunctionDeclaration" ? decl.id?.name : decl.declarations[0]?.id?.name;
+      if (id && knownFns.includes(id)) {
+        for (const c of obj2.leadingComments ?? []) {
+          const caseArgs = parseCaseArgs(c.value);
+          if (!caseArgs) continue;
+          const caseName = /@nudo:case\s+"([^"]+)"/.exec(c.value)?.[1] ?? "?";
+          checkCaseAgainstReqs(id, caseName, caseArgs, c.loc?.start.line);
+        }
+      }
+    }
+    for (const key of Object.keys(obj2)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "leadingComments") continue;
+      const val = obj2[key];
+      if (Array.isArray(val)) val.forEach(visit);
+      else if (val && typeof val === "object") visit(val);
+    }
+  };
+  visit(file);
+  return out;
+}
+function collectParamStructReqs(source, fnName, fileAst) {
+  const reqs = /* @__PURE__ */ new Map();
+  const extracted = extractFn(source, fnName, fileAst);
+  if (!extracted) return reqs;
+  const params = new Set(extracted.params);
+  const body = extracted.body;
+  const BUILTIN_METHODS = /* @__PURE__ */ new Set([
+    "map",
+    "filter",
+    "reduce",
+    "flatMap",
+    "forEach",
+    "some",
+    "every",
+    "find",
+    "findIndex",
+    "includes",
+    "indexOf",
+    "lastIndexOf",
+    "join",
+    "slice",
+    "splice",
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "sort",
+    "reverse",
+    "concat",
+    "at",
+    "replace",
+    "replaceAll",
+    "split",
+    "trim",
+    "toLowerCase",
+    "toUpperCase",
+    "startsWith",
+    "endsWith",
+    "charAt",
+    "charCodeAt",
+    "padStart",
+    "padEnd",
+    "repeat",
+    "toString",
+    "valueOf",
+    "substring",
+    "match",
+    "search",
+    "hasOwnProperty",
+    "keys",
+    "values",
+    "entries",
+    "then",
+    "catch",
+    "finally"
+  ]);
+  const visit = (n, isMethodCallee = false) => {
+    if (!n || typeof n !== "object") return;
+    const obj2 = n;
+    if (obj2.type === "MemberExpression" && !obj2.computed && !isMethodCallee) {
+      const o = obj2.object;
+      const p = obj2.property;
+      if (o?.type === "Identifier" && o.name && params.has(o.name) && p?.type === "Identifier" && p.name) {
+        if (BUILTIN_METHODS.has(p.name)) return;
+        let set = reqs.get(o.name);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          reqs.set(o.name, set);
+        }
+        set.add(p.name);
+      }
+    }
+    if (obj2.type === "CallExpression") {
+      visit(obj2.callee, true);
+      for (const key of Object.keys(obj2)) {
+        if (key === "loc" || key === "start" || key === "end" || key === "callee") continue;
+        const val = obj2[key];
+        if (Array.isArray(val)) val.forEach((v2) => visit(v2, false));
+        else if (val && typeof val === "object") visit(val, false);
+      }
+      return;
+    }
+    for (const key of Object.keys(obj2)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const val = obj2[key];
+      if (Array.isArray(val)) val.forEach((v2) => visit(v2, isMethodCallee));
+      else if (val && typeof val === "object") visit(val, isMethodCallee);
+    }
+  };
+  visit(body);
+  return reqs;
+}
+function evalArgAbs(node, lookupVar) {
+  if (node.type === "Identifier" && typeof node.name === "string" && lookupVar) {
+    return lookupVar(node.name);
+  }
+  try {
+    const env = emptyEnv();
+    if (lookupVar) {
+      const rawGet = env.vars.get.bind(env.vars);
+      env.vars.get = ((name) => {
+        const hit = rawGet(name);
+        if (hit !== void 0) return hit;
+        return lookupVar(name);
+      });
+    }
+    return evalNode(node, env, pTrue, defaultLeakBudget).value;
+  } catch {
+    return void 0;
+  }
+}
+function requireSpecOf(init) {
+  if (init.type === "CallExpression") {
+    const callee = init.callee;
+    const args = init.arguments;
+    if (callee?.type === "Identifier" && callee.name === "require" && args?.[0]?.type === "StringLiteral") {
+      return String(args[0].value);
+    }
+  }
+  if (init.type === "MemberExpression") {
+    const obj2 = init.object;
+    if (obj2) return requireSpecOf(obj2);
+  }
+  return void 0;
+}
+function requireExportName(init) {
+  if (init.type === "MemberExpression" && !init.computed) {
+    const prop = init.property;
+    if (prop?.type === "Identifier") return prop.name;
+  }
+  return void 0;
+}
+function dynamicImportSpec(node) {
+  let n = node;
+  if (n?.type === "AwaitExpression") {
+    n = n.argument;
+  }
+  if (n?.type !== "CallExpression") return void 0;
+  const callee = n.callee;
+  if (callee?.type !== "Import") return void 0;
+  const args = n.arguments;
+  if (args?.[0]?.type === "StringLiteral") return String(args[0].value);
+  return void 0;
+}
+function resolveExportSource(modSrc, fnName, loadSpec, depth = 0) {
+  if (depth > 3) return modSrc;
+  try {
+    if (listTopFunctions(modSrc).includes(fnName)) return modSrc;
+  } catch {
+    return modSrc;
+  }
+  const file = parseSource(modSrc);
+  let nextSpec;
+  for (const stmt of file.program.body) {
+    if (stmt.type !== "ExportNamedDeclaration" && stmt.type !== "ExportAllDeclaration") continue;
+    const src = stmt.source;
+    if (src?.type !== "StringLiteral" || typeof src.value !== "string") continue;
+    if (stmt.type === "ExportAllDeclaration") {
+      nextSpec = String(src.value);
+      break;
+    }
+    const clause = stmt.specifiers ?? [];
+    for (const sp of clause) {
+      if (sp.type !== "ExportSpecifier") continue;
+      const local = sp.local;
+      if (local?.type === "Identifier" && local.name === fnName) {
+        nextSpec = String(src.value);
+        break;
+      }
+    }
+    if (nextSpec) break;
+  }
+  if (!nextSpec) return modSrc;
+  const next = loadSpec(nextSpec);
+  if (!next) return modSrc;
+  return resolveExportSource(next, fnName, loadSpec, depth + 1);
+}
+var STMT_CONTAINER = /* @__PURE__ */ new Set([
+  "File",
+  "Program",
+  "BlockStatement",
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression",
+  "IfStatement",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "DoWhileStatement",
+  "SwitchStatement",
+  "SwitchCase",
+  "TryStatement",
+  "CatchClause",
+  "LabeledStatement",
+  "ExportNamedDeclaration",
+  "ExportDefaultDeclaration",
+  "ExportAllDeclaration",
+  "ClassDeclaration",
+  "ClassBody",
+  "ClassMethod",
+  "StaticBlock",
+  "ObjectMethod"
+]);
+function walkStatements(n, onStmt) {
+  if (!n || typeof n !== "object") return;
+  const obj2 = n;
+  if (typeof obj2.type === "string") onStmt(obj2);
+  if (!STMT_CONTAINER.has(String(obj2.type))) return;
+  for (const key of Object.keys(obj2)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "leadingComments") continue;
+    const val = obj2[key];
+    if (Array.isArray(val)) val.forEach((x) => walkStatements(x, onStmt));
+    else if (val && typeof val === "object") walkStatements(val, onStmt);
+  }
+}
+function collectCallResolvers(source, knownFns, opts) {
+  const knownSet = new Set(knownFns);
+  const aliasToFn = /* @__PURE__ */ new Map();
+  const memberToFn = /* @__PURE__ */ new Map();
+  const externalFn = /* @__PURE__ */ new Map();
+  const externalMember = /* @__PURE__ */ new Map();
+  const file = opts?.file ?? parseSource(source);
+  const load = opts?.loadModule;
+  const fromFile = opts?.fromFile ?? "";
+  const modCache = /* @__PURE__ */ new Map();
+  const loadSpec = (spec) => {
+    if (!load) return void 0;
+    if (!modCache.has(spec)) modCache.set(spec, load(spec, fromFile));
+    return modCache.get(spec);
+  };
+  const bindExternal = (local, modSrc, fnName) => {
+    externalFn.set(local, {
+      source: resolveExportSource(modSrc, fnName, loadSpec),
+      fnName
+    });
+  };
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj2 = n;
+    if (obj2.type === "ImportDeclaration") {
+      const spec = obj2.source;
+      if (spec?.type === "StringLiteral" && typeof spec.value === "string") {
+        const modSrc = loadSpec(String(spec.value));
+        if (modSrc) {
+          for (const sp of obj2.specifiers ?? []) {
+            if (sp.type === "ImportSpecifier") {
+              const imported = sp.imported;
+              const local = sp.local;
+              const exportName = imported?.type === "Identifier" ? imported.name : imported?.type === "StringLiteral" ? String(imported.value) : void 0;
+              if (exportName && local?.name) {
+                bindExternal(local.name, modSrc, exportName);
+              }
+            } else if (sp.type === "ImportNamespaceSpecifier") {
+              const local = sp.local;
+              if (local?.name) {
+                externalMember.set(`${local.name}.__module__`, { source: modSrc, fnName: "" });
+              }
+            }
+          }
+        }
+      }
+    }
+    if (obj2.type === "VariableDeclaration") {
+      for (const d of obj2.declarations ?? []) {
+        const id = d.id;
+        const init = d.init;
+        if (!id || !init) continue;
+        const dynSpec = dynamicImportSpec(init);
+        if (dynSpec) {
+          const modSrc = loadSpec(dynSpec);
+          if (modSrc && id.type === "ObjectPattern") {
+            for (const p of id.properties ?? []) {
+              const key = p.key;
+              const val = p.value;
+              const exported = key?.type === "Identifier" ? key.name : key?.type === "StringLiteral" ? String(key.value) : void 0;
+              const local = val?.type === "Identifier" ? val.name : exported;
+              if (exported && local) bindExternal(local, modSrc, exported);
+            }
+          }
+          if (modSrc && id.type === "Identifier" && id.name) {
+            externalMember.set(`${id.name}.__module__`, { source: modSrc, fnName: "" });
+          }
+        }
+        const spec = requireSpecOf(init);
+        if (spec) {
+          const modSrc = loadSpec(spec);
+          if (id.type === "ObjectPattern" && modSrc) {
+            for (const p of id.properties ?? []) {
+              const key = p.key;
+              const val = p.value;
+              const exported = key?.type === "Identifier" ? key.name : key?.type === "StringLiteral" ? String(key.value) : void 0;
+              const local = val?.type === "Identifier" ? val.name : exported;
+              if (exported && local) {
+                bindExternal(local, modSrc, exported);
+              }
+            }
+          }
+          if (id.type === "Identifier" && id.name && modSrc) {
+            const exportName = requireExportName(init);
+            if (exportName) {
+              bindExternal(id.name, modSrc, exportName);
+            } else {
+              externalMember.set(`${id.name}.__module__`, { source: modSrc, fnName: "" });
+            }
+          }
+        }
+        if (id.type !== "Identifier" || !id.name) continue;
+        if (init.type === "Identifier" && typeof init.name === "string" && knownSet.has(init.name)) {
+          aliasToFn.set(id.name, init.name);
+        }
+        if (init.type === "ObjectExpression") {
+          for (const p of init.properties ?? []) {
+            if (p.type !== "ObjectProperty") continue;
+            const key = p.key;
+            const value = p.value;
+            if (value?.type === "Identifier" && value.name && knownSet.has(value.name)) {
+              const propKey = key?.type === "Identifier" ? key.name : key?.type === "StringLiteral" ? String(key.value) : void 0;
+              if (propKey) memberToFn.set(`${id.name}.${propKey}`, value.name);
+            }
+          }
+        }
+      }
+    }
+  };
+  walkStatements(file, visit);
+  return { aliasToFn, memberToFn, externalFn, externalMember };
+}
+function resolveCalleeFn(callee, resolve, knownFns) {
+  if (callee.type === "Identifier" && typeof callee.name === "string") {
+    const ext = resolve.externalFn.get(callee.name);
+    if (ext) return { external: ext };
+    const aliased = resolve.aliasToFn.get(callee.name);
+    if (aliased) return aliased;
+    if (knownFns.has(callee.name)) return callee.name;
+    return void 0;
+  }
+  if (callee.type === "MemberExpression") {
+    const obj2 = callee.object;
+    const prop = callee.property;
+    if (!callee.computed && obj2?.type === "Identifier" && obj2.name && prop?.type === "Identifier" && prop.name) {
+      const key = `${obj2.name}.${prop.name}`;
+      const extM = resolve.externalMember.get(key);
+      if (extM) return { external: extM };
+      const mod2 = resolve.externalMember.get(`${obj2.name}.__module__`);
+      if (mod2?.source) {
+        return { external: { source: mod2.source, fnName: prop.name } };
+      }
+      const local = resolve.memberToFn.get(key);
+      if (local) return local;
+    }
+  }
+  return void 0;
+}
+function collectForwarders(source, knownFns, resolve, fileAst) {
+  const forwards = /* @__PURE__ */ new Map();
+  const file = fileAst ?? parseSource(source);
+  const tryFn = (name, params, body) => {
+    if (!name || !params.length) return;
+    const paramNames = params.map((p) => p?.type === "Identifier" ? p.name : void 0);
+    if (paramNames.some((n) => !n)) return;
+    let call;
+    if (body?.type === "BlockStatement") {
+      const stmts = body.body ?? [];
+      if (stmts.length !== 1 || stmts[0].type !== "ReturnStatement") return;
+      const arg = stmts[0].argument;
+      if (arg?.type !== "CallExpression") return;
+      call = arg;
+    } else if (body?.type === "CallExpression") {
+      call = body;
+    }
+    if (!call) return;
+    const resolved = resolveCalleeFn(call.callee, resolve, knownFns);
+    if (!resolved || typeof resolved !== "string") return;
+    if (!knownFns.has(resolved) || resolved === name) return;
+    const args = call.arguments ?? [];
+    if (args.length === 0) return;
+    const map = [];
+    for (const a of args) {
+      if (a.type !== "Identifier" || typeof a.name !== "string") return;
+      const idx = paramNames.indexOf(a.name);
+      if (idx < 0) return;
+      map.push(idx);
+    }
+    forwards.set(name, { target: resolved, map });
+  };
+  walkStatements(file, (obj2) => {
+    if (obj2.type === "FunctionDeclaration") {
+      const id = obj2.id;
+      tryFn(
+        id?.name ?? "",
+        obj2.params ?? [],
+        obj2.body
+      );
+    }
+    if (obj2.type === "VariableDeclaration") {
+      for (const d of obj2.declarations ?? []) {
+        const id = d.id;
+        const init = d.init;
+        if (id?.type === "Identifier" && id.name && init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) {
+          tryFn(
+            id.name,
+            init.params ?? [],
+            init.body
+          );
+        }
+      }
+    }
+  });
+  return forwards;
+}
+function scanLiteralCalls(source, knownFns, phi, opts) {
+  const out = [];
+  const file = opts?.file ?? parseSource(source);
+  const knownSet = new Set(knownFns);
+  const resolve = collectCallResolvers(source, knownFns, opts);
+  const forwards = collectForwarders(source, knownSet, resolve, file);
+  const varAbs = opts?.varAbs ?? /* @__PURE__ */ new Map();
+  const flattenPred = (p) => p.op === "and" ? p.args.flatMap(flattenPred) : p.op === "true" ? [] : [p];
+  const checkReqs = (displayName, reqs, paramNames, absArgs, argIndexOf, loc) => {
+    for (const [idx, pred] of reqs) {
+      const argIdx = argIndexOf(idx);
+      if (argIdx === void 0) continue;
+      const arg = absArgs[argIdx];
+      if (!arg) continue;
+      const lv = litValue(arg);
+      const isStr = arg.shape.k === "prim" && arg.shape.type === "string";
+      const strLen = typeof lv === "string" ? lv.length : void 0;
+      const paramName = paramNames[idx] ?? `arg${idx}`;
+      for (const p of flattenPred(pred)) {
+        if (p.op === "typeof") {
+          if (p.t.op !== "var") continue;
+          const expected = p.type;
+          const actualPrim = arg.shape.k === "prim" ? arg.shape.type : arg.shape.k === "obj" || arg.shape.k === "arr" || arg.shape.k === "tuple" ? "object" : arg.shape.k === "fn" ? "function" : void 0;
+          if (actualPrim !== void 0 && actualPrim !== expected) {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+              actual: formatAbs(arg),
+              expected: `typeof ${paramName} = "${expected}"`,
+              suggestion: `\u6539\u7528 ${expected} \u7C7B\u578B\u7684\u503C\uFF0C\u6216\u653E\u5BBD ${paramName} \u7684 refine`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+          continue;
+        }
+        if (lv === void 0) continue;
+        if ((p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") && p.b.op === "lit" && typeof p.b.value === "number") {
+          const n = p.b.value;
+          const opSym = { gt: ">", ge: "\u2265", lt: "<", le: "\u2264" }[p.op];
+          if (p.a.op === "app" && p.a.fn === "length" && strLen !== void 0) {
+            let ok2 = true;
+            if (p.op === "gt") ok2 = strLen > n;
+            if (p.op === "ge") ok2 = strLen >= n;
+            if (p.op === "lt") ok2 = strLen < n;
+            if (p.op === "le") ok2 = strLen <= n;
+            if (!ok2) {
+              const paramName2 = paramNames[idx] ?? `arg${idx}`;
+              out.push({
+                severity: "error",
+                code: "nudo:constraint-violated",
+                message: `${displayName}[${paramName2}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+                actual: formatAbs(arg),
+                expected: `length(${paramName2}) ${opSym} ${n}`,
+                suggestion: `\u6539\u7528\u6EE1\u8DB3\u957F\u5EA6 ${opSym} ${n} \u7684\u503C\uFF0C\u6216\u653E\u5BBD ${paramName2} \u7684\u524D\u7F6E`,
+                fn: displayName,
+                line: loc?.start.line,
+                column: loc?.start.column
+              });
+            }
+            continue;
+          }
+          if (isStr || typeof lv !== "number") continue;
+          let ok = true;
+          if (p.op === "gt") ok = lv > n;
+          if (p.op === "ge") ok = lv >= n;
+          if (p.op === "lt") ok = lv < n;
+          if (p.op === "le") ok = lv <= n;
+          if (!ok) {
+            const paramName2 = paramNames[idx] ?? `arg${idx}`;
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName2}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+              actual: formatAbs(arg),
+              expected: predToString(p),
+              suggestion: `\u6539\u7528\u6EE1\u8DB3 ${predToString(p)} \u7684\u503C\uFF0C\u6216\u653E\u5BBD ${paramName2} \u7684\u524D\u7F6E`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+        }
+      }
+    }
+  };
+  const checkShapeAgainstAbs = (displayName, paramName, constraint, absArg, path, loc) => {
+    if (!constraint.fields) return;
+    if (absArg.shape.k === "unknown" && !absArg.term) return;
+    const slots = absArg.shape.k === "obj" ? absArg.shape.slots : void 0;
+    if (!slots) {
+      if (absArg.shape.k !== "unknown" && absArg.shape.k !== "never") {
+        out.push({
+          severity: "error",
+          code: "nudo:constraint-violated",
+          message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+          actual: formatAbs(absArg),
+          expected: `object shape at ${path}`,
+          suggestion: `\u6539\u7528\u6EE1\u8DB3 ${path} \u5F62\u72B6\u7EA6\u675F\u7684 object`,
+          fn: displayName,
+          line: loc?.start.line,
+          column: loc?.start.column
+        });
+      }
+      return;
+    }
+    for (const [key, field] of Object.entries(constraint.fields)) {
+      const slot = slots[key];
+      const fieldPath = path === paramName ? `${paramName}.${key}` : `${path}.${key}`;
+      if (!slot) {
+        if (!field.optional && !field.constraint.isOptional) {
+          out.push({
+            severity: "error",
+            code: "nudo:constraint-violated",
+            message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+            actual: formatAbs(absArg),
+            expected: `missing field ${fieldPath}`,
+            suggestion: `\u8865\u5168\u5B57\u6BB5 ${fieldPath}`,
+            fn: displayName,
+            line: loc?.start.line,
+            column: loc?.start.column
+          });
+        }
+        continue;
+      }
+      checkFieldConstraint(displayName, paramName, field.constraint, slot.value, fieldPath, loc);
+    }
+  };
+  const checkFieldConstraint = (displayName, paramName, constraint, fieldAbs, fieldPath, loc) => {
+    if (fieldAbs.shape.k === "unknown" && !fieldAbs.term) return;
+    if (constraint.prim && fieldAbs.shape.k === "prim") {
+      const actualPrim = fieldAbs.shape.type;
+      if (actualPrim !== constraint.prim) {
+        out.push({
+          severity: "error",
+          code: "nudo:constraint-violated",
+          message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+          actual: formatAbs(fieldAbs),
+          expected: `typeof ${fieldPath} = "${constraint.prim}"`,
+          suggestion: `\u628A ${fieldPath} \u6539\u6210 ${constraint.prim}`,
+          fn: displayName,
+          line: loc?.start.line,
+          column: loc?.start.column
+        });
+        return;
+      }
+    }
+    if (constraint.int) {
+      const iv = litValue(fieldAbs);
+      if (typeof iv === "number" && !Number.isInteger(iv)) {
+        out.push({
+          severity: "error",
+          code: "nudo:constraint-violated",
+          message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+          actual: formatAbs(fieldAbs),
+          expected: `${fieldPath} is int`,
+          suggestion: `\u628A ${fieldPath} \u6539\u6210\u6574\u6570`,
+          fn: displayName,
+          line: loc?.start.line,
+          column: loc?.start.column
+        });
+      }
+    }
+    if (constraint.fields) {
+      checkShapeAgainstAbs(displayName, paramName, constraint, fieldAbs, fieldPath, loc);
+    }
+    if (constraint.element) {
+      if (fieldAbs.shape.k === "arr") {
+        checkFieldConstraint(
+          displayName,
+          paramName,
+          constraint.element,
+          fieldAbs.shape.element,
+          `${fieldPath}[]`,
+          loc
+        );
+      } else if (fieldAbs.shape.k === "tuple") {
+        const els = fieldAbs.shape.elements;
+        els.forEach((el, i) => {
+          checkFieldConstraint(
+            displayName,
+            paramName,
+            constraint.element,
+            el,
+            `${fieldPath}[${i}]`,
+            loc
+          );
+        });
+      }
+    }
+    const lv = litValue(fieldAbs);
+    const sv = typeof lv === "string" ? lv.length : void 0;
+    const isStr = fieldAbs.shape.k === "prim" && fieldAbs.shape.type === "string";
+    for (const p of constraint.preds) {
+      const flat = p.op === "and" ? p.args : [p];
+      for (const atom of flat) {
+        if ((atom.op === "gt" || atom.op === "ge" || atom.op === "lt" || atom.op === "le") && atom.b.op === "lit" && typeof atom.b.value === "number") {
+          const n = atom.b.value;
+          const opSym = { gt: ">", ge: "\u2265", lt: "<", le: "\u2264" }[atom.op];
+          if (atom.a.op === "app" && atom.a.fn === "length") {
+            if (sv === void 0) continue;
+            let ok2 = true;
+            if (atom.op === "gt") ok2 = sv > n;
+            if (atom.op === "ge") ok2 = sv >= n;
+            if (atom.op === "lt") ok2 = sv < n;
+            if (atom.op === "le") ok2 = sv <= n;
+            if (!ok2) {
+              out.push({
+                severity: "error",
+                code: "nudo:constraint-violated",
+                message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+                actual: formatAbs(fieldAbs),
+                expected: `length(${fieldPath}) ${opSym} ${n}`,
+                suggestion: `\u6539\u7528\u6EE1\u8DB3\u957F\u5EA6 ${opSym} ${n} \u7684 ${fieldPath}`,
+                fn: displayName,
+                line: loc?.start.line,
+                column: loc?.start.column
+              });
+            }
+            continue;
+          }
+          if (lv === void 0 || typeof lv !== "number" || isStr) continue;
+          let ok = true;
+          if (atom.op === "gt") ok = lv > n;
+          if (atom.op === "ge") ok = lv >= n;
+          if (atom.op === "lt") ok = lv < n;
+          if (atom.op === "le") ok = lv <= n;
+          if (!ok) {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+              actual: formatAbs(fieldAbs),
+              expected: `${fieldPath} ${opSym} ${n}`,
+              suggestion: `\u6539\u7528\u6EE1\u8DB3 ${fieldPath} ${opSym} ${n} \u7684\u503C\uFF0C\u6216\u653E\u5BBD ${paramName} \u7684\u524D\u7F6E`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+        }
+      }
+    }
+  };
+  const checkShapeReqs = (displayName, reqs, paramNames, absArgs, argIndexOf, loc) => {
+    for (const [idx, entry] of reqs) {
+      const c = entry.constraint;
+      if (!c.fields && !c.element && !c.int && !c.prim) continue;
+      const argIdx = argIndexOf(idx);
+      if (argIdx === void 0) continue;
+      const arg = absArgs[argIdx];
+      if (!arg) continue;
+      const paramName = entry.param || paramNames[idx] || `arg${idx}`;
+      if (c.fields) {
+        checkShapeAgainstAbs(displayName, paramName, c, arg, paramName, loc);
+      }
+      if (c.element) {
+        if (arg.shape.k === "arr") {
+          checkFieldConstraint(
+            displayName,
+            paramName,
+            c.element,
+            arg.shape.element,
+            `${paramName}[]`,
+            loc
+          );
+        } else if (arg.shape.k === "tuple") {
+          const els = arg.shape.elements;
+          els.forEach((el, i) => {
+            checkFieldConstraint(
+              displayName,
+              paramName,
+              c.element,
+              el,
+              `${paramName}[${i}]`,
+              loc
+            );
+          });
+        } else if (arg.shape.k !== "unknown" && arg.shape.k !== "any") {
+          out.push({
+            severity: "error",
+            code: "nudo:constraint-violated",
+            message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+            actual: formatAbs(arg),
+            expected: `array at ${paramName}`,
+            suggestion: `\u6539\u7528\u6EE1\u8DB3 array \u7EA6\u675F\u7684\u503C`,
+            fn: displayName,
+            line: loc?.start.line,
+            column: loc?.start.column
+          });
+        }
+      }
+      if (c.int) {
+        const iv = litValue(arg);
+        if (typeof iv === "number" && !Number.isInteger(iv)) {
+          out.push({
+            severity: "error",
+            code: "nudo:constraint-violated",
+            message: `${displayName}[${paramName}]: \u5B9E\u53C2 \u22AD \u524D\u7F6E`,
+            actual: formatAbs(arg),
+            expected: `${paramName} is int`,
+            suggestion: `\u6539\u7528\u6574\u6570`,
+            fn: displayName,
+            line: loc?.start.line,
+            column: loc?.start.column
+          });
+        }
+      }
+    }
+  };
+  const parseCallArgs = (args) => {
+    const absArgs = [];
+    let hasInfo = false;
+    for (const a of args ?? []) {
+      if (a.type === "NumericLiteral" && typeof a.value === "number") {
+        absArgs.push(numLit(a.value));
+        hasInfo = true;
+      } else if (a.type === "UnaryExpression" && a.operator === "-" && a.argument?.type === "NumericLiteral") {
+        const num2 = a.argument;
+        absArgs.push(numLit(-num2.value));
+        hasInfo = true;
+      } else if (a.type === "ObjectExpression") {
+        const abs2 = evalArgAbs(a, (n) => varAbs.get(n));
+        absArgs.push(abs2 ?? absUnknown());
+        if (abs2 && abs2.shape.k === "obj") hasInfo = true;
+      } else if (a.type === "ArrayExpression") {
+        const abs2 = evalArgAbs(a, (n) => varAbs.get(n));
+        absArgs.push(abs2 ?? absUnknown());
+        if (abs2 && (abs2.shape.k === "arr" || abs2.shape.k === "tuple")) hasInfo = true;
+      } else if (a.type === "StringLiteral" && typeof a.value === "string") {
+        absArgs.push({
+          shape: { k: "prim", type: "string" },
+          term: { op: "lit", value: a.value },
+          conf: "exact"
+        });
+        hasInfo = true;
+      } else if (a.type === "Identifier" && typeof a.name === "string") {
+        const abs2 = varAbs.get(a.name);
+        absArgs.push(abs2 ?? absUnknown());
+        if (abs2 && abs2.shape.k !== "unknown") hasInfo = true;
+      } else {
+        absArgs.push(absUnknown());
+      }
+    }
+    return { absArgs, hasInfo };
+  };
+  const checkOneCall = (fnName, args, loc) => {
+    if (!knownFns.includes(fnName)) return;
+    checkArgStructures(fnName, source, args, loc);
+    const { absArgs, hasInfo } = parseCallArgs(args);
+    if (!hasInfo || absArgs.length === 0) return;
+    const g = generalizeFromAst(fnName, source, {
+      file,
+      refine: {
+        loadModule: opts?.loadModule,
+        fromFile: opts?.fromFile ?? ""
+      }
+    });
+    const paramNames = g?.params ?? [];
+    const optsR = {
+      loadModule: opts?.loadModule,
+      fromFile: opts?.fromFile ?? ""
+    };
+    const ownFull = refineToIndexedFull(source, fnName, paramNames, optsR);
+    checkShapeReqs(fnName, ownFull, paramNames, absArgs, (i) => i, loc);
+    checkReqs(
+      fnName,
+      ownFull.map(([i, e]) => [i, e.pred]),
+      paramNames,
+      absArgs,
+      (i) => i,
+      loc
+    );
+    const fwd = forwards.get(fnName);
+    if (fwd) {
+      const tg = generalizeFromAst(fwd.target, source, file ? { file } : {});
+      const tParams = tg?.params ?? [];
+      const tFull = refineToIndexedFull(source, fwd.target, tParams, optsR);
+      if (tFull.length > 0) {
+        const wrapperArgOfTarget = /* @__PURE__ */ new Map();
+        fwd.map.forEach((wrapperIdx, targetIdx) => {
+          wrapperArgOfTarget.set(targetIdx, wrapperIdx);
+        });
+        const mapArg = (targetIdx) => wrapperArgOfTarget.get(targetIdx);
+        checkShapeReqs(`${fnName}\u2192${fwd.target}`, tFull, tParams, absArgs, mapArg, loc);
+        checkReqs(
+          `${fnName}\u2192${fwd.target}`,
+          tFull.map(([i, e]) => [i, e.pred]),
+          tParams,
+          absArgs,
+          mapArg,
+          loc
+        );
+      }
+    }
+  };
+  const checkExternalCall = (ext, args, displayName, loc) => {
+    checkArgStructures(ext.fnName, ext.source, args, loc, displayName);
+    const { absArgs, hasInfo } = parseCallArgs(args);
+    if (!hasInfo || absArgs.length === 0) return;
+    let full = [];
+    let paramNames = [];
+    try {
+      const g = generalizeFromAst(ext.fnName, ext.source);
+      paramNames = g?.params ?? [];
+      full = refineToIndexedFull(ext.source, ext.fnName, paramNames, {
+        loadModule: opts?.loadModule,
+        fromFile: opts?.fromFile ?? ""
+      });
+    } catch {
+      return;
+    }
+    checkShapeReqs(displayName, full, paramNames, absArgs, (i) => i, loc);
+    checkReqs(
+      displayName,
+      full.map(([i, e]) => [i, e.pred]),
+      paramNames,
+      absArgs,
+      (i) => i,
+      loc
+    );
+  };
+  const checkHofFnRelArgs = (g, args, loc, displayName, evalArg) => {
+    const fnRels = g.fnRels;
+    if (!fnRels) return;
+    for (let i = 0; i < g.params.length; i++) {
+      const pname = g.params[i];
+      const rel = fnRels.get(pname);
+      if (!rel) continue;
+      const expected = rel.abs;
+      if (expected.shape.k !== "fn") continue;
+      const argNode = args[i];
+      if (!argNode) continue;
+      const absArg = evalArg(argNode);
+      if (!absArg) continue;
+      if (absArg.shape.k === "any" || absArg.shape.k === "unknown") continue;
+      if (getFnImpl(absArg)) continue;
+      if (absArg.shape.k === "sum") {
+        const okAny = absArg.shape.members.some(
+          (m) => hofFnArgOk(m, expected)
+        );
+        if (okAny) continue;
+      }
+      if (!hofFnArgOk(absArg, expected)) {
+        const isPromote = rel.source === "promote";
+        out.push({
+          severity: isPromote ? "warning" : "error",
+          code: "nudo:arg-structure",
+          message: `${displayName}[${pname}]: \u5B9E\u53C2\u4E0D\u662F\u53EF\u8C03\u7528\u7684 fn`,
+          actual: formatAbs(absArg),
+          expected: formatShape(expected),
+          suggestion: `\u671F\u671B ${formatShape(expected)}`,
+          fn: displayName,
+          line: loc?.start.line,
+          column: loc?.start.column
+        });
+      }
+    }
+  };
+  const checkArgStructures = (fnName, fnSource, args, loc, displayName) => {
+    let structReqs;
+    let paramNames;
+    let gFn;
+    try {
+      const sameFile = fnSource === source;
+      structReqs = collectParamStructReqs(fnSource, fnName, sameFile ? file : void 0);
+      gFn = generalizeFromAst(
+        fnName,
+        fnSource,
+        sameFile && file ? { file } : {}
+      );
+      paramNames = gFn?.params ?? [];
+    } catch {
+      return;
+    }
+    if (gFn?.fnRels && gFn.fnRels.size > 0) {
+      checkHofFnRelArgs(
+        gFn,
+        args,
+        loc,
+        displayName ?? fnName,
+        (n) => evalArgAbs(n, (x) => varAbs.get(x))
+      );
+    }
+    if (structReqs.size === 0) return;
+    let refinedParams;
+    try {
+      const sameFile = fnSource === source;
+      const reqs = refineToIndexedFull(fnSource, fnName, paramNames, {
+        loadModule: opts?.loadModule,
+        fromFile: opts?.fromFile ?? ""
+      });
+      if (reqs.length > 0) {
+        refinedParams = new Set(reqs.map(([, e]) => e.param));
+      }
+    } catch {
+    }
+    for (let i = 0; i < args.length; i++) {
+      const pname = paramNames[i];
+      if (!pname) continue;
+      if (refinedParams?.has(pname)) continue;
+      const keys = structReqs.get(pname);
+      if (!keys || keys.size === 0) continue;
+      const argNode = args[i];
+      if (!argNode) continue;
+      const absArg = evalArgAbs(argNode, (n) => varAbs.get(n));
+      if (!absArg || absArg.shape.k === "unknown") continue;
+      const isLeny = absArg.shape.k === "arr" || absArg.shape.k === "tuple" || absArg.shape.k === "prim" && absArg.shape.type === "string";
+      const needKeys = isLeny ? [...keys].filter((k) => k !== "length") : [...keys];
+      if (needKeys.length === 0) continue;
+      const slots = {};
+      for (const k of needKeys) slots[k] = { value: absUnknown() };
+      const target = abs({ k: "obj", slots }, void 0, void 0, "exact");
+      const leq = leqAbs(absArg, target);
+      if (!leq.ok) {
+        const name = displayName ?? fnName;
+        out.push({
+          severity: "error",
+          code: "nudo:arg-structure",
+          message: `${name}[${pname}]: \u5B9E\u53C2\u7ED3\u6784 \u22AD \u5F62\u53C2`,
+          actual: formatAbs(absArg),
+          expected: formatAbs(target),
+          suggestion: leq.reason ?? `\u8865\u5168 ${pname} \u4E0A\u88AB\u8BBF\u95EE\u7684\u5B57\u6BB5`,
+          fn: name,
+          line: loc?.start.line,
+          column: loc?.start.column
+        });
+      }
+    }
+  };
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj2 = n;
+    if (obj2.type === "CallExpression") {
+      const callee = obj2.callee;
+      const args = obj2.arguments ?? [];
+      const resolved = resolveCalleeFn(callee, resolve, knownSet);
+      if (typeof resolved === "string") {
+        checkOneCall(resolved, args, obj2.loc);
+      } else if (resolved?.external) {
+        const name = resolved.external.fnName || "require()";
+        checkExternalCall(resolved.external, args, name, obj2.loc);
+      }
+    }
+    for (const key of Object.keys(obj2)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const val = obj2[key];
+      if (Array.isArray(val)) val.forEach(visit);
+      else if (val && typeof val === "object") visit(val);
+    }
+  };
+  visit(file);
+  return out;
+}
+
+// src/algebra/check-report.ts
+function serializeCheckJson(r) {
+  return {
+    version: 1,
+    file: r.file,
+    ok: r.ok,
+    summary: { ...r.summary },
+    signatures: r.signatures.map((s) => ({
+      name: s.name,
+      params: [...s.params],
+      display: s.display,
+      detail: s.detail,
+      conf: s.conf,
+      abs: formatAbs(s.abs)
+    })),
+    issues: r.issues.map((i) => ({
+      severity: i.severity,
+      code: i.code,
+      message: i.message,
+      ...i.fn !== void 0 ? { fn: i.fn } : {},
+      ...i.line !== void 0 ? { line: i.line } : {},
+      ...i.column !== void 0 ? { column: i.column } : {},
+      ...i.actual !== void 0 ? { actual: i.actual } : {},
+      ...i.expected !== void 0 ? { expected: i.expected } : {},
+      ...i.suggestion !== void 0 ? { suggestion: i.suggestion } : {}
+    }))
+  };
+}
+function formatCheckReport(r, opts = {}) {
+  const lines = [];
+  lines.push(`nudo check  ${r.file}`);
+  lines.push(r.ok ? "OK" : "FAILED");
+  lines.push(
+    `  ${r.summary.errors} error \xB7 ${r.summary.warnings} warning \xB7 ${r.summary.infos} info \xB7 ${r.summary.functions} fn`
+  );
+  if (r.signatures.length > 0) {
+    lines.push("");
+    lines.push("signatures");
+    for (const s of r.signatures) {
+      lines.push(`  ${s.name}(${s.params.join(", ")})  ${s.display}`);
+      if (opts.verbose) {
+        for (const ln of s.detail.split("\n").slice(1)) {
+          lines.push(`  ${ln}`);
+        }
+      }
+    }
+  }
+  if (r.issues.length === 0) {
+    lines.push("");
+    lines.push("(no issues)");
+  } else {
+    lines.push("");
+    lines.push("issues");
+    for (const i of r.issues) {
+      const loc = i.line != null ? `L${i.line}` : "";
+      const head = [i.severity.toUpperCase(), loc, i.fn].filter(Boolean).join(" ");
+      lines.push(`  [${head}] ${i.message}  (${i.code})`);
+      if (i.actual) lines.push(`      actual:   ${i.actual}`);
+      if (i.expected) lines.push(`      expected: ${i.expected}`);
+      if (i.suggestion) lines.push(`      \u2192 ${i.suggestion}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/algebra/inlay.ts
+function listFunctions(source) {
+  const file = parseSource(source);
+  const out = [];
+  const visitDecl = (decl) => {
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      const fd = decl;
+      out.push({ name: fd.id.name, node: fd });
+    }
+    if (decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations ?? []) {
+        if (d.id?.type === "Identifier" && d.init && (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")) {
+          out.push({ name: d.id.name, node: d.init });
+        }
+      }
+    }
+  };
+  for (const stmt of file.program.body) {
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      visitDecl(stmt.declaration);
+    } else if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+      visitDecl(stmt.declaration);
+    } else {
+      visitDecl(stmt);
+    }
+  }
+  return out;
+}
+function paramPreds(source, fnName, paramNames) {
+  const byIndex = /* @__PURE__ */ new Map();
+  const file = parseSource(source);
+  const paramIndex = new Map(paramNames.map((p, i) => [p, i]));
+  const pushCmp = (test, consequent) => {
+    if (test?.type !== "BinaryExpression") return;
+    const left = test.left;
+    const right = test.right;
+    const op = test.operator;
+    if (left?.type !== "Identifier" || !left.name || !paramIndex.has(left.name) || right?.type !== "NumericLiteral" || typeof right.value !== "number") {
+      return;
+    }
+    const isReturnParam = consequent?.type === "ReturnStatement" && consequent.argument?.type === "Identifier" && consequent.argument.name === left.name;
+    if (!isReturnParam) return;
+    const idx = paramIndex.get(left.name);
+    const t = { op: "var", id: left.name };
+    const b = { op: "lit", value: right.value };
+    let pred;
+    if (op === ">") pred = { op: "gt", a: t, b };
+    else if (op === ">=") pred = { op: "ge", a: t, b };
+    else if (op === "<") pred = { op: "lt", a: t, b };
+    else if (op === "<=") pred = { op: "le", a: t, b };
+    if (!pred) return;
+    const list = byIndex.get(idx) ?? [];
+    list.push(pred);
+    byIndex.set(idx, list);
+  };
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj2 = n;
+    if (obj2.type === "IfStatement") {
+      const test = obj2.test;
+      const consequent = obj2.consequent;
+      pushCmp(test, consequent);
+      if (test?.type === "LogicalExpression" && test.operator === "&&") {
+        pushCmp(test.left, consequent);
+        pushCmp(test.right, consequent);
+      }
+    }
+    for (const key of Object.keys(obj2)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const val = obj2[key];
+      if (Array.isArray(val)) val.forEach(visit);
+      else if (val && typeof val === "object") visit(val);
+    }
+  };
+  visit(file);
+  const byName = /* @__PURE__ */ new Map();
+  for (const [idx, preds] of byIndex) {
+    const name = paramNames[idx];
+    if (name) byName.set(name, preds);
+  }
+  return byName;
+}
+function collectAbsInlays(source, refineOpts) {
+  const inlays = [];
+  for (const { name, node } of listFunctions(source)) {
+    let g;
+    try {
+      g = generalizeFromAst(name, source, refineOpts ? { refine: refineOpts } : {});
+    } catch {
+      continue;
+    }
+    if (!g) continue;
+    const params = g.params;
+    const predsByName = /* @__PURE__ */ new Map();
+    if (g.entryReqs) {
+      for (const r of g.entryReqs) {
+        predsByName.set(r.param, [r.pred]);
+      }
+    }
+    for (const [k, v2] of paramPreds(source, name, params)) {
+      if (!predsByName.has(k)) predsByName.set(k, v2);
+    }
+    const fnNode = node;
+    const paramList = fnNode.params ?? [];
+    for (let i = 0; i < paramList.length; i++) {
+      const p = paramList[i];
+      const pname = params[i] ?? p?.name;
+      if (!p?.loc || !pname) continue;
+      const preds = predsByName.get(pname);
+      if (preds && preds.length > 0) {
+        const text = preds.map(predToString).join(" \u2227 ");
+        inlays.push({
+          line: p.loc.end.line,
+          character: p.loc.end.column,
+          label: `  where ${text}`,
+          kind: "parameter"
+        });
+      }
+    }
+    const bodyLoc = fnNode.body?.loc;
+    if (bodyLoc?.start) {
+      const retShape = formatShape(g.symbolic);
+      let label = `: ${retShape}`;
+      if (g.symbolic.term && g.symbolic.term.op !== "lit") {
+        label += ` = ${termToString(g.symbolic.term)}`;
+      }
+      if (g.symbolic.pred && g.symbolic.pred.op !== "true") {
+        label += `  where ${predToString(g.symbolic.pred)}`;
+      }
+      inlays.push({
+        line: bodyLoc.start.line,
+        character: Math.max(0, bodyLoc.start.column),
+        label: `${label}  `,
+        kind: "type"
+      });
+    }
+  }
+  return inlays;
+}
+
+// src/algebra/denote.ts
+function denoteGuard(a, v2) {
+  const lv = litValue(a);
+  if (lv !== void 0 && (!a.pred || a.pred.op === "true")) {
+    return `${v2} === ${JSON.stringify(lv)}`;
+  }
+  const shape2 = denoteShape(a.shape, v2);
+  const pred = denotePred(a, v2);
+  if (shape2 === "true") return pred;
+  if (pred === "true") return shape2;
+  return `(${shape2}) && (${pred})`;
+}
+function denoteShape(s, v2) {
+  switch (s.k) {
+    case "never":
+      return "false";
+    case "unknown":
+    case "any":
+      return "true";
+    case "prim":
+      switch (s.type) {
+        case "number":
+          return `typeof ${v2} === "number"`;
+        case "string":
+          return `typeof ${v2} === "string"`;
+        case "boolean":
+          return `typeof ${v2} === "boolean"`;
+        case "bigint":
+          return `typeof ${v2} === "bigint"`;
+        case "symbol":
+          return `typeof ${v2} === "symbol"`;
+        default:
+          return "true";
+      }
+    case "obj": {
+      const checks = [`typeof ${v2} === "object"`, `${v2} !== null`];
+      for (const [key, slot] of Object.entries(s.slots)) {
+        const access = `${v2}.${key}`;
+        const inner = denoteGuard(slot.value, access);
+        if (slot.optional) {
+          if (inner !== "true") checks.push(`(${access} === undefined || ${inner})`);
+        } else {
+          if (inner !== "true") checks.push(inner);
+        }
+      }
+      return checks.join(" && ");
+    }
+    case "arr":
+      return `Array.isArray(${v2}) && ${v2}.every((item) => ${denoteGuard(s.element, "item")})`;
+    case "tuple": {
+      const checks = [`Array.isArray(${v2})`];
+      const minLen = s.elements.length;
+      checks.push(s.rest ? `${v2}.length >= ${minLen}` : `${v2}.length === ${minLen}`);
+      s.elements.forEach((el, i) => {
+        const inner = denoteGuard(el, `${v2}[${i}]`);
+        if (inner !== "true") checks.push(inner);
+      });
+      if (s.rest) {
+        const rest = denoteGuard(s.rest, "item");
+        if (rest !== "true") {
+          checks.push(`${v2}.slice(${minLen}).every((item) => ${rest})`);
+        }
+      }
+      return checks.join(" && ");
+    }
+    case "fn":
+      return `typeof ${v2} === "function"`;
+    case "eff":
+      if (s.eff === "promise") return `${v2} instanceof Promise`;
+      return "true";
+    case "brand":
+      return denoteShape(s.shape.shape, v2);
+    case "sum": {
+      if (s.members.length === 0) return "false";
+      const parts = s.members.map((m) => denoteGuard(m, v2));
+      return `(${parts.join(" || ")})`;
+    }
+  }
+}
+function denotePred(a, v2) {
+  const p = a.pred;
+  if (!p || p.op === "true") {
+    const lv = litValue(a);
+    if (lv !== void 0) return `${v2} === ${JSON.stringify(lv)}`;
+    return "true";
+  }
+  return predAsJs(p, v2, a);
+}
+function predAsJs(p, v2, a) {
+  switch (p.op) {
+    case "true":
+      return "true";
+    case "false":
+      return "false";
+    case "and":
+      return p.args.map((x) => predAsJs(x, v2, a)).join(" && ");
+    case "or":
+      return `(${p.args.map((x) => predAsJs(x, v2, a)).join(" || ")})`;
+    case "not": {
+      const inner = predAsJs(p.arg, v2, a);
+      return inner === "true" ? "false" : `!(${inner})`;
+    }
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+    case "eq":
+    case "ne": {
+      const op = { gt: ">", ge: ">=", lt: "<", le: "<=", eq: "===", ne: "!==" }[p.op];
+      const leftIsValue = termIsValue(p.a, a);
+      const rightLit = litOfTerm(p.b);
+      if (leftIsValue && rightLit !== void 0) {
+        return `${v2} ${op} ${JSON.stringify(rightLit)}`;
+      }
+      const leftLit = litOfTerm(p.a);
+      const rightIsValue = termIsValue(p.b, a);
+      if (rightIsValue && leftLit !== void 0) {
+        return `${JSON.stringify(leftLit)} ${op} ${v2}`;
+      }
+      if (leftLit !== void 0 && rightLit !== void 0) {
+        return `${JSON.stringify(leftLit)} ${op} ${JSON.stringify(rightLit)}`;
+      }
+      return "true";
+    }
+    default:
+      return "true";
+  }
+}
+function litOfTerm(t) {
+  return t.op === "lit" ? t.value : void 0;
+}
+function termIsValue(t, a) {
+  if (t.op === "var") return true;
+  if (t.op === "lit") {
+    const lv = litValue(a);
+    return lv !== void 0 && Object.is(lv, t.value);
+  }
+  return false;
+}
+
+// src/algebra/bridge.ts
+var confByTv = /* @__PURE__ */ new WeakMap();
+function setTvConfidence(tv, conf) {
+  if (tv && typeof tv === "object") confByTv.set(tv, conf);
+}
+function getTvConfidence(tv) {
+  if (tv && typeof tv === "object") return confByTv.get(tv);
+  return void 0;
+}
+function absToTypeValue(a) {
+  let conf = a.conf;
+  let result;
+  switch (a.shape.k) {
+    case "never":
+      result = T.never;
+      break;
+    case "unknown":
+      result = T.unknown;
+      break;
+    case "any":
+      result = T.unknown;
+      break;
+    case "prim": {
+      const lv = litValue(a);
+      if (lv !== void 0) {
+        result = T.literal(lv);
+        break;
+      }
+      if (isTemplateLike(a) && a.shape.k === "prim" && a.shape.type === "string") {
+        const parts = templatePartsOf(a).map(absToTypeValue);
+        result = createTemplate(parts);
+        break;
+      }
+      const prim = primToT(a.shape.type);
+      if (a.pred && a.pred.op !== "true") {
+        const refined = tryEncodeRefined(prim, a);
+        if (refined) {
+          result = refined;
+        } else {
+          result = prim;
+          conf = confJoin(conf, "widened");
+        }
+      } else {
+        result = prim;
+        if (a.term && a.term.op !== "lit") conf = confJoin(conf, "widened");
+      }
+      break;
+    }
+    case "obj": {
+      const props = {};
+      for (const [k, slot] of Object.entries(a.shape.slots)) {
+        let v2 = absToTypeValue(slot.value);
+        if (slot.optional) {
+          v2 = T.union(v2, T.undefined);
+        }
+        props[k] = v2;
+      }
+      result = T.object(props);
+      if (a.shape.open) conf = confJoin(conf, "widened");
+      break;
+    }
+    case "arr":
+      result = T.array(absToTypeValue(a.shape.element));
+      break;
+    case "tuple":
+      result = T.tuple(a.shape.elements.map(absToTypeValue));
+      break;
+    case "fn": {
+      const body = { type: "BlockStatement", body: [], directives: [] };
+      result = T.fn(a.shape.params, body, null);
+      break;
+    }
+    case "brand":
+      result = T.instanceOf(a.shape.name, brandProps(a.shape.shape));
+      break;
+    case "eff":
+      result = T.promise(absToTypeValue(a.shape.inner));
+      break;
+    case "sum":
+      result = T.union(...a.shape.members.map(absToTypeValue));
+      break;
+    default:
+      result = T.unknown;
+      conf = confJoin(conf, "partial");
+  }
+  setTvConfidence(result, conf);
+  return result;
+}
+function primToT(type) {
+  switch (type) {
+    case "number":
+      return T.number;
+    case "string":
+      return T.string;
+    case "boolean":
+      return T.boolean;
+    case "bigint":
+      return T.bigint;
+    case "symbol":
+      return T.symbol;
+    default:
+      return T.unknown;
+  }
+}
+function brandProps(shape2) {
+  if (shape2.shape.k === "obj") {
+    const out = {};
+    for (const [k, slot] of Object.entries(shape2.shape.slots)) {
+      out[k] = absToTypeValue(slot.value);
+    }
+    return out;
+  }
+  return {};
+}
+function tryEncodeRefined(base, a) {
+  if (base.kind !== "primitive" || base.type !== "number") return void 0;
+  const p = a.pred;
+  if (!p) return void 0;
+  if ((p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") && p.b.op === "lit" && typeof p.b.value === "number") {
+    const n = p.b.value;
+    const op = p.op;
+    const check = (value) => {
+      if (typeof value !== "number") return false;
+      switch (op) {
+        case "gt":
+          return value > n;
+        case "ge":
+          return value >= n;
+        case "lt":
+          return value < n;
+        case "le":
+          return value <= n;
+      }
+    };
+    const opSym = op === "gt" ? ">" : op === "ge" ? ">=" : op === "lt" ? "<" : "<=";
+    return T.refine(base, {
+      name: `number (${opSym} ${n})`,
+      meta: { op, n, pred: predToString(p) },
+      check
+    });
+  }
+  return void 0;
+}
+function typeValueToAbs(tv) {
+  if (!tv) return abs({ k: "unknown" }, void 0, void 0, "partial");
+  const confOr = (fallback) => getTvConfidence(tv) ?? fallback;
+  switch (tv.kind) {
+    case "never":
+      return abs({ k: "never" }, void 0, void 0, confOr("exact"));
+    case "unknown":
+      return abs(
+        { k: "unknown" },
+        void 0,
+        void 0,
+        confOr("partial")
+      );
+    case "literal":
+      if (typeof tv.value === "bigint") {
+        return abs(
+          { k: "prim", type: "bigint" },
+          void 0,
+          void 0,
+          confOr("exact")
+        );
+      }
+      return abs(
+        shapeOfLit(tv.value),
+        lit(tv.value),
+        pTrue,
+        confOr("exact")
+      );
+    case "primitive":
+      return abs({ k: "prim", type: tv.type }, void 0, void 0, confOr("exact"));
+    case "refined": {
+      const tplParts = getTemplateParts(tv);
+      if (tplParts) {
+        return createTemplateAbs(tplParts.map(typeValueToAbs));
+      }
+      const base = typeValueToAbs(tv.base);
+      const decoded = tryDecodeRefinedPred(tv, base.term);
+      return abs(
+        base.shape,
+        base.term ?? (decoded ? v("_r") : void 0),
+        decoded ?? base.pred,
+        confOr(confJoin(base.conf, "path"))
+      );
+    }
+    case "object": {
+      const slots = {};
+      for (const [k, v2] of Object.entries(tv.properties)) {
+        slots[k] = { value: typeValueToAbs(v2) };
+      }
+      return abs({ k: "obj", slots }, void 0, void 0, confOr("exact"));
+    }
+    case "array":
+      return abs(
+        { k: "arr", element: typeValueToAbs(tv.element) },
+        void 0,
+        void 0,
+        confOr("exact")
+      );
+    case "tuple":
+      return abs(
+        { k: "tuple", elements: tv.elements.map(typeValueToAbs) },
+        void 0,
+        void 0,
+        confOr("exact")
+      );
+    case "function": {
+      const params = tv.params ?? [];
+      return abs({ k: "fn", params }, void 0, void 0, confOr("exact"));
+    }
+    case "promise":
+      return abs(
+        { k: "eff", eff: "promise", inner: typeValueToAbs(tv.value) },
+        void 0,
+        void 0,
+        confOr("exact")
+      );
+    case "instance": {
+      const slots = {};
+      for (const [k, v2] of Object.entries(tv.properties ?? {})) {
+        slots[k] = { value: typeValueToAbs(v2) };
+      }
+      const inner = abs({ k: "obj", slots }, void 0, void 0, confOr("exact"));
+      return abs(
+        { k: "brand", name: tv.className, shape: inner },
+        void 0,
+        void 0,
+        confOr("exact")
+      );
+    }
+    case "union":
+      return abs(
+        { k: "sum", members: tv.members.map(typeValueToAbs) },
+        void 0,
+        void 0,
+        confOr("path")
+      );
+    default:
+      return abs({ k: "unknown" }, void 0, void 0, confOr("partial"));
+  }
+}
+function tryDecodeRefinedPred(tv, term) {
+  if (tv.kind !== "refined") return void 0;
+  const meta = tv.refinement.meta;
+  const op = meta?.op;
+  const n = meta?.n;
+  if (typeof n !== "number") return void 0;
+  if (op !== "gt" && op !== "ge" && op !== "lt" && op !== "le") return void 0;
+  const t = term ?? v("_r");
+  const b = lit(n);
+  switch (op) {
+    case "gt":
+      return gt(t, b);
+    case "ge":
+      return ge(t, b);
+    case "lt":
+      return lt(t, b);
+    case "le":
+      return le(t, b);
+  }
+}
+function shapeOfLit(v2) {
+  if (typeof v2 === "number") return { k: "prim", type: "number" };
+  if (typeof v2 === "string") return { k: "prim", type: "string" };
+  if (typeof v2 === "boolean") return { k: "prim", type: "boolean" };
+  if (typeof v2 === "bigint") return { k: "prim", type: "bigint" };
+  return { k: "unknown" };
+}
+function bridgeIsLossy(a) {
+  const reasons = [];
+  if (a.term && a.term.op !== "lit") {
+    reasons.push(`dropped term ${termToString(a.term)}`);
+  }
+  if (a.pred && a.pred.op !== "true") {
+    const tv = absToTypeValue(a);
+    if (tv.kind !== "refined") {
+      reasons.push(`dropped pred ${predToString(a.pred)}`);
+    }
+  }
+  return { lossy: reasons.length > 0, reasons };
+}
 export {
+  $add,
+  $arr,
+  $async,
+  $asyncReturn,
+  $await,
+  $call,
+  $callNamed,
+  $catchVal,
+  $class,
+  $concat,
+  $div,
+  $elems,
+  $eq,
+  $fnVal,
+  $for,
+  $forIter,
+  $forOf,
+  $fork,
+  $ge,
+  $gen,
+  $get,
+  $gt,
+  $idx,
+  $idxSet,
+  $invoke,
+  $invokeSuper,
+  $join,
+  $le,
+  $len,
+  $lit,
+  $lt,
+  $mod,
+  $mul,
+  $ne,
+  $neg,
+  $new,
+  $not,
+  $obj,
+  $optionalGet,
+  $optionalInvoke,
+  $orDefault,
+  $set,
+  $setKey,
+  $spread,
+  $staticInvoke,
+  $sub,
+  $super,
+  $switch,
+  $thisGet,
+  $thisSet,
+  $throw,
+  $typeof,
+  $while,
+  $whileSeq,
+  $yield,
+  DEFAULT_MAX_LOOP_ITERS,
+  MAX_CALL_DEPTH,
+  MAX_TOTAL_CALLS,
+  NudoThrow,
   Ops,
+  SELF,
   T,
+  abs,
+  absFunction,
+  absToString,
+  absToTypeValue,
+  add,
+  alphaOf,
+  analyzeFn,
+  and,
+  anyVar,
+  app,
+  applyAbsFn,
   applyBinaryOp,
+  applyCallbackAbs,
+  array,
+  asAbs,
+  asAbsVal,
+  attachFnImpl,
+  awaitAbs,
+  betaOf,
+  bindImports,
+  bool,
+  boolLit,
+  boolean,
+  bridgeIsLossy,
+  buildArgsFromAssume,
+  callAbsMethod,
+  callFunction,
+  callTranspiledExport,
+  callTranspiledExportFull,
+  canSkipLiteralCallScan,
+  checkArg,
+  checkCall,
+  checkSource,
+  classFromMethods,
+  clearBClasses,
+  cmp,
+  coerceAsyncReturn,
+  collapseLiteralUnion,
+  collapseToOptional,
+  collectAbsExports,
+  collectAbsInlays,
+  collectAbsNodeTypes,
+  concatString,
   concatTemplates,
+  confJoin,
+  constraintToEntryAbs,
   createEnvironment,
+  createHofCollectCtx,
   createRange,
   createTemplate,
+  createTemplateAbs,
+  currentExecPhi,
+  currentPhi,
   deepCloneTypeValue,
+  defaultLeakBudget,
+  defineClass,
+  definitelyNotNullishShape,
+  denoteGuard,
+  describePhi,
   dispatchBinaryOp,
   dispatchMethod,
   dispatchProperty,
+  div,
+  emptyEnv,
+  emptyPhi,
+  eq,
+  evalArrayStatic,
+  evalBuiltinInstanceMethod,
+  evalBuiltinNew,
+  evalDateCtor,
+  evalDateMethod,
+  evalDateStatic,
+  evalGlobalFn,
+  evalJsonMethod,
+  evalMathMethod,
+  evalMethodBody,
+  evalNamespaceCall,
+  evalNode,
+  evalNumberStatic,
+  evalObjectMethod,
+  evalProgramAbs,
+  evalPromiseCtor,
+  evalPromiseStatic,
+  evalRegExpCtor,
+  evalRegExpMethod,
+  evalSource,
+  evictCheckSourceMemoForPaths,
+  evictGeneralizeMemoForPaths,
+  exceedsBudget,
+  execNudoModule,
+  extractAllLoadSpecs,
+  extractFn,
+  extractNudoImports,
+  extractRefineReturnFromSource,
+  extractRefinesFromSource,
+  falseConstraint,
+  findAbsAtPosition,
+  fnFingerprints,
+  fnOf,
+  formatAbs,
+  formatAbsMultiline,
+  formatCheckReport,
+  formatDiagnostics,
+  formatShape,
+  formatShapeSlot,
+  ge,
+  geNum,
+  generalizeAll,
+  generalizeFromAst,
+  generalizeSourceKeyPart,
+  getAbsOrigin,
+  getAbsProperty,
+  getBCallCollector,
+  getBClass,
+  getCheckSourceMemoSize,
+  getClass,
+  getClassChain,
+  getFnImpl,
+  getFnNameAndBodies,
+  getFnSig,
+  getGeneralizeMemoSize,
   getKnownPrefix,
   getKnownSuffix,
+  getParseSourceCacheSize,
   getPrimitiveTypeOf,
   getRangeMeta,
   getRefinedBase,
   getTemplateParts,
+  getTerm,
+  getTvConfidence,
+  gt,
+  gtNum,
+  hashSource,
+  implies,
+  instanceOf,
+  instantiateClass,
+  instantiateConstraint,
+  instantiateReturn,
+  isDefinitelyFalse,
+  isDefinitelyTrue,
+  isExactLit,
+  isFnSig,
+  isNudoConstraint,
+  isNudoThrow,
+  isNullishLitAbs,
+  isNumPrim,
+  isObj,
   isRange,
+  isRelFn,
+  isStrPrim,
   isSubtypeOf,
   isTemplate,
+  isTemplateLike,
+  joinAbs,
+  joinFunctions,
+  joinObjects,
+  joinValues,
+  le,
+  leNum,
+  leakIfNeeded,
+  lenTerm,
+  leqAbs,
+  listFunctionNames,
+  lit,
+  litValue,
+  loadModuleDepsFingerprint,
+  lookupMethod,
+  lookupMethodWithOwner,
+  lookupSuperMethod,
+  lt,
+  ltNum,
+  makeSum,
+  mapElementFallback,
+  maybeLeak,
   mergeObjectProperties,
+  mock,
+  mockHelperToTypeValue,
+  mod,
+  mul,
   narrowType,
+  ne,
+  negAbs,
+  never,
+  normPath,
+  not,
+  notAbs,
+  noteMemberDispatchMiss,
+  notePrimMemberMissing,
+  noteUnknownMemberMissing,
+  num,
+  numLit,
+  numVar,
+  number,
+  numericBounds,
+  obj,
+  objOf,
+  or,
+  pFalse,
+  pTrue,
+  parseSource,
+  phiAnd,
+  popPhi,
+  predEquals,
+  predToString,
+  predVars,
+  projectBrand,
+  projectFlatMapResult,
+  promoteParamShape,
+  ptypeof,
+  pushPhi,
+  recordMemberDiag,
+  refineToIndexedFull,
+  registerBClass,
+  relationFingerprint,
+  relationFn,
+  resetAbsCallBudget,
+  resetCheckSourceMemo,
+  resetFnFpCache,
+  resetGeneralizeMemo,
+  resetHashSourceCache,
+  resetLeakCounter,
+  resetNudoModuleExecCache,
+  resetParseSourceCache,
+  resetPhi,
+  resolveDepPath,
+  runTranspiled,
+  serializeCheckJson,
+  setAbsAssignCollector,
+  setAbsCallCollector,
+  setAbsNodeCollector,
+  setAbsTruncationCollector,
+  setApplyCallbackHost,
+  setBCallCollector,
+  setMemberDiagCollector,
+  setTvConfidence,
+  shape,
+  shapeOfTerm,
+  shapeOnlyFn,
+  shapeToString,
+  simplifyTerm,
   simplifyUnion,
+  snapshotAbs,
+  spread,
+  spy,
+  stableAnalyzeKeySource,
+  str,
+  strLit,
+  strictEqAbs,
+  string,
+  stripTypes,
+  stub,
+  sub,
+  substAbs,
+  substPred,
+  substPredAbs,
   subtractType,
+  superNameOf,
+  tagAbsOrigin,
+  templatePartsOf,
+  termDepth,
+  termEquals,
+  termNodes,
+  termToString,
+  transpile,
+  transpileExpression,
+  transpileFile,
+  transpileSource,
+  trueConstraint,
+  tryPromoteDirectCall,
+  tryPromoteForOfIteratee,
+  tryPromoteHofCallback,
+  tryPromoteReceiverAsArr,
   typeValueEquals,
+  typeValueToAbs,
   typeValueToString,
-  widenLiteral
+  typeofAbs,
+  undefAbs,
+  unknown,
+  v,
+  widenLiteral,
+  withExecPhi,
+  withPhiConstraint,
+  withVar,
+  wrapPromise
 };