@nudojs/core 1.0.1 → 1.1.1

package/dist/chunk-V2I7VXFZ.js

@@ -0,0 +1,4923 @@
+import {
+  $invoke,
+  $new,
+  abs,
+  and,
+  anyAbs,
+  app,
+  callTranspiledExportFull,
+  defaultLeakBudget,
+  emptyEnv,
+  eq,
+  evalExprAbs,
+  foldRequireSpecArg,
+  formalParamDisplayNames,
+  formalParamsFromNodes,
+  formatAbs,
+  formatShape,
+  formatShapeSlot,
+  freeIdentifiers,
+  ge,
+  getFnImpl,
+  getSlot,
+  gt,
+  joinAbs,
+  le,
+  lit,
+  litValue,
+  locateContractParam,
+  lt,
+  numLit,
+  or,
+  pTrue,
+  parseSource,
+  predToString,
+  primToTypeof,
+  ptypeof,
+  runTranspiledOptionsMemoKey,
+  snapshotAbs,
+  termToString,
+  tryRunTranspiled,
+  unknown,
+  v,
+  withExecPhi
+} from "./chunk-CDH7QCGQ.js";
+
+// src/algebra/constraint.ts
+var SELF = "__nudo_self__";
+function selfTerm() {
+  return v(SELF);
+}
+function getTerm(obj, key) {
+  return app("get", [obj, 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);
+}
+var intFlaggedBuilders = /* @__PURE__ */ new WeakSet();
+function isIntFlag(c) {
+  return c.int === true || intFlaggedBuilders.has(c);
+}
+function makeBuilder(prim, preds, extra) {
+  const fields = extra?.fields;
+  const element = extra?.element;
+  const isInt = extra?.int;
+  const optional = extra?.optional;
+  const members = extra?.members;
+  const fnSlot = extra?.fn;
+  const base = {
+    __nudoConstraint: true,
+    ...prim ? { prim } : {},
+    preds: [...preds],
+    ...fields ? { fields } : {},
+    ...element ? { element } : {},
+    ...optional ? { isOptional: true } : {},
+    ...members ? { members } : {},
+    ...fnSlot ? { fn: fnSlot } : {}
+  };
+  const add = (p) => makeBuilder(prim, [...preds, p], extra);
+  const builder = Object.assign(
+    /* @__PURE__ */ Object.create(null),
+    base,
+    {
+      gt: (n) => add(gt(selfTerm(), lit(n))),
+      ge: (n) => add(ge(selfTerm(), lit(n))),
+      lt: (n) => add(lt(selfTerm(), lit(n))),
+      le: (n) => add(le(selfTerm(), lit(n))),
+      int: () => makeBuilder(prim ?? "number", preds, { ...extra, int: true }),
+      min: (n) => add(ge(lenTerm(selfTerm()), lit(n))),
+      max: (n) => add(le(lenTerm(selfTerm()), lit(n))),
+      length: (n) => add(and(ge(lenTerm(selfTerm()), lit(n)), le(lenTerm(selfTerm()), lit(n)))),
+      shift: (n) => {
+        if (!Number.isFinite(n))
+          throw new Error("nudo shift(): offset must be a finite number");
+        if (fields || element || members || fnSlot)
+          throw new Error("nudo shift(): only numeric scalar constraint chains are allowed (shape/array/union/fn are not supported)");
+        if (prim !== void 0 && prim !== "number")
+          throw new Error(`nudo shift(): only numeric chains are allowed (prim=${prim})`);
+        return makeBuilder(prim, shiftBoundPreds(preds, n), extra);
+      },
+      optional: () => makeBuilder(prim, preds, { ...extra, optional: true })
+    }
+  );
+  if (isInt) intFlaggedBuilders.add(builder);
+  return builder;
+}
+function shiftBoundPreds(preds, n) {
+  return preds.map((p) => {
+    if (p.op !== "gt" && p.op !== "ge" && p.op !== "lt" && p.op !== "le")
+      throw new Error(`nudo shift(): predicate ${p.op} is not supported (only gt/ge/lt/le constant bounds)`);
+    const { a, b } = p;
+    if (b.op !== "lit" || typeof b.value !== "number")
+      throw new Error("nudo shift(): the right-hand side of a constant bound must be a numeric literal");
+    if (termHasApp(a, "length") || termHasApp(b, "length"))
+      throw new Error("nudo shift(): length(...) bounds are not supported");
+    return { op: p.op, a, b: lit(b.value + n) };
+  });
+}
+function termHasApp(t, fn2) {
+  if (t.op !== "app") return false;
+  if (t.fn === fn2) return true;
+  return t.args.some((x) => termHasApp(x, fn2));
+}
+function number() {
+  return makeBuilder("number", []);
+}
+function string() {
+  return makeBuilder("string", []);
+}
+function boolean() {
+  return makeBuilder("boolean", []);
+}
+function any() {
+  return makeBuilder(void 0, []);
+}
+function array(item) {
+  return makeBuilder(void 0, [], {
+    element: asNestedConstraint(item, "array(item)")
+  });
+}
+function shape(fields) {
+  const mapped = {};
+  for (const [k, v2] of Object.entries(fields)) {
+    const constraint = asNestedConstraint(v2, `shape \u5B57\u6BB5 '${k}'`);
+    mapped[k] = {
+      constraint,
+      ...constraint.isOptional ? { optional: true } : {}
+    };
+  }
+  return makeBuilder(void 0, [], { fields: mapped });
+}
+function toPlainConstraint(c) {
+  if (!isConstraint(c))
+    throw new Error("nudo: expected a constraint value (number()/string()/\u2026 or a combinator)");
+  return {
+    __nudoConstraint: true,
+    ...c.prim ? { prim: c.prim } : {},
+    preds: [...c.preds],
+    ...c.fields ? { fields: c.fields } : {},
+    ...c.element ? { element: c.element } : {},
+    // isIntFlag 统一读取：builder（int 是方法）查 WeakSet，纯数据看 === true
+    ...isIntFlag(c) ? { int: true } : {},
+    ...c.isOptional ? { isOptional: true } : {},
+    ...c.members ? { members: c.members } : {},
+    ...c.fn ? { fn: c.fn } : {}
+  };
+}
+function litC(v2) {
+  const prim = typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : typeof v2 === "boolean" ? "boolean" : void 0;
+  return makeBuilder(prim, [eq(selfTerm(), lit(v2))]);
+}
+function asNestedConstraint(x, ctx) {
+  if (isConstraint(x)) return toPlainConstraint(x);
+  if (x === null || x === void 0 || typeof x === "number" || typeof x === "string" || typeof x === "boolean") {
+    return toPlainConstraint(litC(x));
+  }
+  throw new Error(
+    `nudo: ${ctx} expects a constraint value (number()/string()/\u2026) or a concrete literal; received a non-constraint`
+  );
+}
+function union(...cs) {
+  if (cs.length === 0)
+    throw new Error("nudo union(): at least one member constraint is required");
+  return makeBuilder(void 0, [], {
+    members: cs.map((c) => asNestedConstraint(c, "union member"))
+  });
+}
+function fn(params, returns, opts) {
+  const normalized = {};
+  for (const [k, v2] of Object.entries(params)) {
+    normalized[k] = asNestedConstraint(v2, `fn param '${k}'`);
+  }
+  return makeBuilder(void 0, [], {
+    fn: {
+      params: normalized,
+      ...returns !== void 0 ? { returns: asNestedConstraint(returns, "fn return value") } : {},
+      ...opts?.throws !== void 0 ? { throws: asNestedConstraint(opts.throws, "fn throws") } : {}
+    }
+  });
+}
+function andC(...cs) {
+  if (cs.length === 0)
+    throw new Error("nudo and(): at least one constraint is required");
+  let prim;
+  let isInt = false;
+  let allOptional = true;
+  const preds = [];
+  for (const c of cs) {
+    if (!isConstraint(c))
+      throw new Error("nudo: expected a constraint value (number()/string()/\u2026 or a combinator)");
+    if (c.fields || c.element || c.members || c.fn)
+      throw new Error("nudo and(): Phase 1 supports scalar constraint conjunction only (shape/array/union/fn are not supported)");
+    if (c.prim) {
+      if (prim !== void 0 && prim !== c.prim)
+        throw new Error(`nudo and(): inconsistent prim (${prim} vs ${c.prim})`);
+      prim = c.prim;
+    }
+    preds.push(...c.preds);
+    if (isIntFlag(c)) isInt = true;
+    if (!c.isOptional) allOptional = false;
+  }
+  return makeBuilder(prim, preds, {
+    ...isInt ? { int: true } : {},
+    ...allOptional ? { optional: true } : {}
+  });
+}
+function partial(c) {
+  if (!isConstraint(c) || !c.fields)
+    throw new Error("nudo partial(): only shape(...) constraints are accepted");
+  const fields = {};
+  for (const [k, f] of Object.entries(c.fields)) {
+    fields[k] = {
+      constraint: { ...toPlainConstraint(f.constraint), isOptional: true },
+      optional: true
+    };
+  }
+  return makeBuilder(c.prim, c.preds, { fields });
+}
+function pick(c, keys) {
+  if (!isConstraint(c) || !c.fields)
+    throw new Error("nudo pick(): only shape(...) constraints are accepted");
+  const fields = {};
+  for (const k of keys) {
+    const f = c.fields[k];
+    if (f) fields[k] = f;
+  }
+  return makeBuilder(c.prim, c.preds, { fields });
+}
+function omit(c, keys) {
+  if (!isConstraint(c) || !c.fields)
+    throw new Error("nudo omit(): only shape(...) constraints are accepted");
+  const drop = new Set(keys);
+  const fields = {};
+  for (const [k, f] of Object.entries(c.fields)) {
+    if (!drop.has(k)) fields[k] = f;
+  }
+  return makeBuilder(c.prim, c.preds, { fields });
+}
+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 substPred(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) => substPred(x, paramName)));
+    default:
+      return p;
+  }
+}
+function instantiateConstraint(c, paramName) {
+  if (c.fields) {
+    const parts = [];
+    for (const [key, field] of Object.entries(c.fields)) {
+      if (field.optional || field.constraint.isOptional) continue;
+      const fieldTerm = getTerm(v(paramName), key);
+      parts.push(instantiateOnTerm(field.constraint, fieldTerm));
+    }
+    if (c.prim) parts.push(ptypeof(v(paramName), primToTypeof(c.prim)));
+    if (parts.length === 0) return { op: "true" };
+    return parts.length === 1 ? parts[0] : and(...parts);
+  }
+  if (c.members) {
+    const disj = or(
+      ...c.members.map((m) => instantiateOnTerm(m, v(paramName)))
+    );
+    const own = c.preds.map((p) => substPred(p, paramName));
+    return own.length === 0 ? disj : and(...own, disj);
+  }
+  if (c.fn) {
+    const own = c.preds.map((p) => substPred(p, paramName));
+    return own.length === 0 ? pTrue : and(...own);
+  }
+  const preds = c.preds.map((p) => substPred(p, paramName));
+  if (c.prim && c.preds.length === 0) {
+    return ptypeof(v(paramName), primToTypeof(c.prim));
+  }
+  return preds.length === 0 ? { op: "true" } : preds.length === 1 ? preds[0] : and(...preds);
+}
+function instantiateOnTerm(c, t) {
+  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;
+    }
+  };
+  if (c.fields) {
+    const parts = [];
+    for (const [key, field] of Object.entries(c.fields)) {
+      if (field.optional || field.constraint.isOptional) continue;
+      parts.push(instantiateOnTerm(field.constraint, getTerm(t, key)));
+    }
+    if (parts.length === 0) return { op: "true" };
+    return parts.length === 1 ? parts[0] : and(...parts);
+  }
+  if (c.members) {
+    const disj = or(...c.members.map((m) => instantiateOnTerm(m, t)));
+    const own = c.preds.map(subst);
+    return own.length === 0 ? disj : and(...own, disj);
+  }
+  if (c.fn) {
+    const own = c.preds.map(subst);
+    return own.length === 0 ? pTrue : and(...own);
+  }
+  const preds = c.preds.map(subst);
+  if (c.prim && c.preds.length === 0) return ptypeof(t, primToTypeof(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 memberLitValue(m) {
+  const leaves = [];
+  const visit2 = (p2) => {
+    if (p2.op === "and") {
+      p2.args.forEach(visit2);
+      return;
+    }
+    leaves.push(p2);
+  };
+  m.preds.forEach(visit2);
+  if (leaves.length !== 1) return void 0;
+  const p = leaves[0];
+  if (p.op !== "eq") return void 0;
+  if (p.a.op === "var" && p.b.op === "lit") return p.b.value;
+  if (p.b.op === "var" && p.a.op === "lit") return p.a.value;
+  return void 0;
+}
+function samePrimLiteralUnionAbs(members, t) {
+  if (members.length === 0) return void 0;
+  const values = [];
+  let prim;
+  for (const m of members) {
+    const v2 = memberLitValue(m);
+    if (v2 === void 0) return void 0;
+    if (v2 === null) return void 0;
+    const mp = m.prim ?? (typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : "boolean");
+    if (prim === void 0) prim = mp;
+    else if (prim !== mp) return void 0;
+    values.push(v2);
+  }
+  if (prim === void 0) return void 0;
+  const uniq = [];
+  for (const v2 of values) {
+    if (!uniq.some((u) => Object.is(u, v2))) uniq.push(v2);
+  }
+  const disj = or(
+    ...uniq.map((v2) => eq(t, lit(v2)))
+  );
+  return abs({ k: "prim", type: prim }, t, disj, "path");
+}
+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.members) {
+    const litUnion = samePrimLiteralUnionAbs(c.members, t);
+    if (litUnion) return litUnion;
+    const joined = c.members.map((m) => constraintOnTermAbs(m, t)).reduce((a, b) => joinAbs(a, b));
+    if (joined.shape.k === "prim" && joined.pred === void 0 && c.members.every((m) => m.prim === joined.shape.type)) {
+      const type = joined.shape.type;
+      return abs({ k: "prim", type }, t, ptypeof(t, primToTypeof(type)), "path");
+    }
+    return joined;
+  }
+  if (c.fn) {
+    const paramNames = Object.keys(c.fn.params);
+    const paramTypes = paramNames.map(
+      (p, i) => constraintOnTermAbs(c.fn.params[p], v(`x${i}`))
+    );
+    const returnType = c.fn.returns ? constraintOnTermAbs(c.fn.returns, v("ret")) : unknown;
+    return abs(
+      { k: "fn", params: paramNames, paramTypes, returnType },
+      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");
+  }
+  const allEqNull = c.preds.length > 0 && c.preds.every(
+    (p) => p.op === "eq" && (p.b.op === "lit" && p.b.value === null || p.a.op === "lit" && p.a.value === null)
+  );
+  if (allEqNull) {
+    return abs({ k: "unknown" }, 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");
+}
+function fnConstraintToEntryReqs(c) {
+  if (!c.fn) throw new Error("nudo fnConstraintToEntryReqs(): constraint is not in fn() form");
+  return Object.entries(c.fn.params).map(([param, constraint]) => ({
+    param,
+    constraint
+  }));
+}
+function throwConstraintToKinds(c) {
+  if (!c) return void 0;
+  const out = /* @__PURE__ */ new Set();
+  let any2 = false;
+  const note = (s) => {
+    if (s === "*" || s === "any") any2 = true;
+    else if (s) out.add(s);
+  };
+  const walk = (x) => {
+    if (x.members) {
+      for (const m of x.members) walk(m);
+      return;
+    }
+    for (const p of x.preds) {
+      if (p.op !== "eq" && p.op !== "ne") continue;
+      for (const side of [p.a, p.b]) {
+        if (side.op === "lit" && typeof side.value === "string") note(side.value);
+      }
+    }
+  };
+  walk(c);
+  if (any2) return "*";
+  if (out.size > 0) return [...out];
+  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/sidecar-path.ts
+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 isNodeModulesPath(p) {
+  const f = normPath(p);
+  if (f === "node_modules" || f.startsWith("node_modules/")) return true;
+  return f.includes("/node_modules/") || f.endsWith("/node_modules");
+}
+function sidecarPathOf(file) {
+  const f = normPath(file);
+  if (f.endsWith(".mjs")) return f.slice(0, -4) + ".nudo.js";
+  if (f.endsWith(".js")) return f.slice(0, -3) + ".nudo.js";
+  if (f.endsWith(".mts")) return f.slice(0, -4) + ".nudo.ts";
+  if (f.endsWith(".ts")) return f.slice(0, -3) + ".nudo.ts";
+  return `${f}.nudo.js`;
+}
+
+// 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;
+}
+var refineDiagCollector = null;
+var refineDiagSeq = 0;
+var refineDiags = [];
+var MAX_REFINE_DIAGS = 1024;
+function setRefineDiagCollector(fn2) {
+  refineDiagCollector = fn2;
+}
+function refineDiagCount() {
+  return refineDiagSeq;
+}
+function takeRefineDiags() {
+  const out = refineDiags.map((e) => e.d);
+  refineDiags.length = 0;
+  return out;
+}
+function takeRefineDiagsSince(since) {
+  const out = [];
+  let kept = 0;
+  for (const e of refineDiags) {
+    if (e.seq > since) out.push(e.d);
+    else refineDiags[kept++] = e;
+  }
+  refineDiags.length = kept;
+  return out;
+}
+function collectDiag(d) {
+  if (refineDiags.length >= MAX_REFINE_DIAGS) refineDiags.shift();
+  refineDiags.push({ seq: ++refineDiagSeq, d });
+  refineDiagCollector?.(d);
+}
+var NudoSidecarError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "NudoSidecarError";
+    this.code = code;
+  }
+};
+var sidecarInjects = {
+  number,
+  string,
+  boolean,
+  shape,
+  array,
+  lit: litC,
+  union,
+  fn,
+  and: andC,
+  partial,
+  pick,
+  omit
+};
+function isSidecarSpec(spec) {
+  return spec.endsWith(".nudo.js") || spec.endsWith(".nudo.ts");
+}
+function sidecarImportNames(stmt) {
+  const out = [];
+  for (const s of stmt.specifiers) {
+    if (s.type === "ImportSpecifier") {
+      out.push({
+        local: s.local.name,
+        imported: s.imported.type === "Identifier" ? s.imported.name : s.imported.value
+      });
+    } else if (s.type === "ImportNamespaceSpecifier") {
+      out.push({ local: s.local.name, ns: true });
+    } else {
+      out.push({ local: s.local.name });
+    }
+  }
+  return out;
+}
+function rewriteSidecarSource(src, fromFile) {
+  const keepTs = fromFile?.endsWith(".nudo.ts") === true;
+  const ast = parseSource(src, keepTs ? { keepTs: true } : void 0);
+  const cuts = [];
+  const exportPairs = [];
+  const imports = [];
+  const DEFAULT_LOCAL = "__nudoDefault";
+  const badExport = (what) => {
+    collectDiag({
+      code: "nudo:interface-load",
+      message: `sidecar ${what}; recognized export forms are 'export const <name> = \u2026' and 'export default <constraint|fn>'`,
+      file: fromFile
+    });
+  };
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      imports.push({ spec: stmt.source.value, names: sidecarImportNames(stmt) });
+      if (stmt.start != null && stmt.end != null) {
+        cuts.push({ start: stmt.start, end: stmt.end, text: "" });
+      }
+      continue;
+    }
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && (stmt.declaration.type === "TSTypeAliasDeclaration" || stmt.declaration.type === "TSInterfaceDeclaration" || stmt.declaration.type === "TSEnumDeclaration")) {
+      if (stmt.start != null && stmt.end != null) {
+        cuts.push({ start: stmt.start, end: stmt.end, text: "" });
+      }
+      continue;
+    }
+    if (stmt.type === "ExportNamedDeclaration") {
+      const decl = stmt.declaration;
+      if (decl?.type === "VariableDeclaration" && stmt.start != null && decl.start != null) {
+        if (decl.kind === "const") {
+          let simple = true;
+          for (const d of decl.declarations) {
+            if (d.id.type === "Identifier") exportPairs.push({ key: d.id.name, expr: d.id.name });
+            else simple = false;
+          }
+          if (!simple) badExport("'export const' with destructuring pattern");
+        } else {
+          badExport(`'export ${decl.kind}'`);
+        }
+        cuts.push({ start: stmt.start, end: decl.start, text: "" });
+        continue;
+      }
+      if ((decl?.type === "FunctionDeclaration" || decl?.type === "ClassDeclaration") && stmt.start != null && decl.start != null) {
+        const kind = decl.type === "FunctionDeclaration" ? "function" : "class";
+        badExport(`'export ${kind} ${decl.id?.name ?? "(anonymous)"}'`);
+        cuts.push({ start: stmt.start, end: decl.start, text: "" });
+        continue;
+      }
+      badExport("'export { \u2026 }' (list / re-export)");
+      if (stmt.start != null && stmt.end != null) {
+        cuts.push({ start: stmt.start, end: stmt.end, text: "" });
+      }
+      continue;
+    }
+    if (stmt.type === "ExportDefaultDeclaration") {
+      const decl = stmt.declaration;
+      if (decl && (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") && stmt.start != null && decl.start != null) {
+        if (decl.id?.name) {
+          exportPairs.push({ key: decl.id.name, expr: decl.id.name });
+          exportPairs.push({ key: "default", expr: decl.id.name });
+        } else {
+          exportPairs.push({ key: "default", expr: DEFAULT_LOCAL });
+          if (decl.start != null && decl.end != null) {
+            const kind = decl.type === "FunctionDeclaration" ? "function" : "class";
+            cuts.push({
+              start: stmt.start,
+              end: decl.start,
+              text: `var ${DEFAULT_LOCAL} = `
+            });
+            void kind;
+          }
+        }
+        if (decl.id?.name) {
+          cuts.push({ start: stmt.start, end: decl.start, text: "" });
+        }
+        continue;
+      }
+      if (decl && stmt.start != null && decl.start != null && decl.end != null) {
+        exportPairs.push({ key: "default", expr: DEFAULT_LOCAL });
+        cuts.push({
+          start: stmt.start,
+          end: decl.start,
+          text: `var ${DEFAULT_LOCAL} = `
+        });
+        cuts.push({ start: decl.end, end: stmt.end ?? decl.end, text: ";" });
+        continue;
+      }
+      badExport("'export default'");
+      if (stmt.start != null && stmt.end != null) {
+        cuts.push({ start: stmt.start, end: stmt.end, text: "" });
+      }
+      continue;
+    }
+    if (stmt.type === "ExportAllDeclaration") {
+      badExport("'export * from \u2026'");
+      if (stmt.start != null && stmt.end != null) {
+        cuts.push({ start: stmt.start, end: stmt.end, text: "" });
+      }
+    }
+  }
+  if (fromFile?.endsWith(".nudo.ts")) {
+    for (const cut of collectTsSyntaxCuts(ast.program, src)) {
+      cuts.push({ start: cut.start, end: cut.end, text: "" });
+    }
+  }
+  cuts.sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const c of cuts) {
+    const last = merged[merged.length - 1];
+    if (last && c.start <= last.end && last.text === "" && c.text === "") {
+      last.end = Math.max(last.end, c.end);
+    } else {
+      merged.push({ start: c.start, end: c.end, text: c.text });
+    }
+  }
+  let code = "";
+  let pos = 0;
+  for (const c of merged) {
+    if (c.start < pos) continue;
+    code += src.slice(pos, c.start) + c.text;
+    pos = c.end;
+  }
+  code += src.slice(pos);
+  return { code, exportPairs, imports };
+}
+var TS_STMT_CUT_TYPES = /* @__PURE__ */ new Set([
+  "TSInterfaceDeclaration",
+  "TSTypeAliasDeclaration",
+  "TSEnumDeclaration",
+  "TSDeclareFunction",
+  "TSModuleDeclaration",
+  "TSImportEqualsDeclaration"
+]);
+function collectTsSyntaxCuts(node, src, cuts = []) {
+  if (!node || typeof node !== "object") return cuts;
+  if (Array.isArray(node)) {
+    for (const x of node) collectTsSyntaxCuts(x, src, cuts);
+    return cuts;
+  }
+  const o = node;
+  if (typeof o.start === "number" && typeof o.end === "number") {
+    if (typeof o.type === "string" && TS_STMT_CUT_TYPES.has(o.type)) {
+      cuts.push({ start: o.start, end: o.end });
+      return cuts;
+    }
+    if (o.type === "TSAsExpression" || o.type === "TSSatisfiesExpression") {
+      collectTsSyntaxCuts(o.expression, src, cuts);
+      const exprEnd = o.expression?.end;
+      if (typeof exprEnd === "number") cuts.push({ start: exprEnd, end: o.end });
+      return cuts;
+    }
+    if (o.type === "TSNonNullExpression") {
+      collectTsSyntaxCuts(o.expression, src, cuts);
+      const exprEnd = o.expression?.end;
+      if (typeof exprEnd === "number") cuts.push({ start: exprEnd, end: o.end });
+      return cuts;
+    }
+    if (o.type === "TSTypeAssertion") {
+      collectTsSyntaxCuts(o.expression, src, cuts);
+      const exprStart = o.expression?.start;
+      if (typeof exprStart === "number") cuts.push({ start: o.start, end: exprStart });
+      return cuts;
+    }
+    const ta = o.typeAnnotation;
+    if (ta && typeof ta.start === "number" && typeof ta.end === "number") {
+      let start = ta.start;
+      if (src[start - 1] === "?") start -= 1;
+      cuts.push({ start, end: ta.end });
+    }
+    const rt = o.returnType;
+    if (rt && typeof rt.start === "number" && typeof rt.end === "number") {
+      cuts.push({ start: rt.start, end: rt.end });
+    }
+    for (const key of ["typeParameters", "typeArguments"]) {
+      const tp = o[key];
+      if (tp && typeof tp.start === "number" && typeof tp.end === "number") {
+        cuts.push({ start: tp.start, end: tp.end });
+      }
+    }
+    if (o.optional === true && !ta && typeof o.end === "number" && src[o.end] === "?") {
+      cuts.push({ start: o.end, end: o.end + 1 });
+    }
+    if (o.declare === true) {
+      cuts.push({ start: o.start, end: o.end });
+      return cuts;
+    }
+  }
+  for (const key of Object.keys(o)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") {
+      continue;
+    }
+    collectTsSyntaxCuts(o[key], src, cuts);
+  }
+  return cuts;
+}
+function execSidecar(src, opts, chain, preloaded) {
+  const fromFile = opts?.fromFile;
+  const { code, exportPairs, imports } = rewriteSidecarSource(src, fromFile);
+  const prologue = [];
+  const deps = {};
+  for (const imp of imports) {
+    const relative = imp.spec.startsWith(".") || imp.spec.startsWith("/");
+    if (!relative) {
+      for (const n of imp.names) {
+        if (n.ns) {
+          collectDiag({
+            code: "nudo:interface-load",
+            message: `sidecar namespace import '${n.local}' from '${imp.spec}' is not supported (import named builders only)`,
+            file: fromFile
+          });
+          prologue.push(`var ${n.local} = __nudoInjects;`);
+        } else if (n.imported !== void 0) {
+          if (!(n.imported in sidecarInjects)) {
+            collectDiag({
+              code: "nudo:interface-load",
+              message: `sidecar import '{ ${n.imported} }' from '${imp.spec}' is not an injected builder`,
+              file: fromFile
+            });
+          }
+          if (n.local !== n.imported || !(n.imported in sidecarInjects)) {
+            prologue.push(`var ${n.local} = __nudoInjects[${JSON.stringify(n.imported)}];`);
+          }
+        } else {
+          collectDiag({
+            code: "nudo:interface-load",
+            message: `sidecar default import '${n.local}' from '${imp.spec}' has no default export to bind (sidecars export named constraints only)`,
+            file: fromFile
+          });
+          prologue.push(`var ${n.local} = undefined;`);
+        }
+      }
+      continue;
+    }
+    const load = opts?.loadModule;
+    if (!load || !fromFile) {
+      collectDiag({
+        code: "nudo:interface-load",
+        message: `sidecar import '${imp.spec}' is unresolvable (no loadModule for relative specifier)`,
+        file: fromFile
+      });
+      for (const n of imp.names) deps[n.local] = void 0;
+      continue;
+    }
+    if (!isSidecarSpec(imp.spec)) {
+      collectDiag({
+        code: "nudo:interface-load",
+        message: `sidecar import '${imp.spec}' unsupported: relative imports must target .nudo.js/.nudo.ts`,
+        file: fromFile
+      });
+      for (const n of imp.names) deps[n.local] = void 0;
+      continue;
+    }
+    const canonical = resolveDepPath(fromFile, imp.spec);
+    if (isNodeModulesPath(canonical)) {
+      collectDiag({
+        code: "nudo:interface-load",
+        message: `sidecar import '${imp.spec}' resolves into node_modules (${canonical}); ambient sidecar loading never crosses node_modules`,
+        file: fromFile
+      });
+      for (const n of imp.names) deps[n.local] = void 0;
+      continue;
+    }
+    if (chain.includes(canonical)) {
+      throw new NudoSidecarError(
+        "nudo:interface-cycle",
+        `sidecar import cycle: ${[...chain, canonical].join(" \u2192 ")}`
+      );
+    }
+    const depSrc = preloaded.has(canonical) ? preloaded.get(canonical) : load(imp.spec, fromFile);
+    if (depSrc === void 0) {
+      collectDiag({
+        code: "nudo:interface-load",
+        message: `sidecar import '${imp.spec}' is unresolvable (loadModule returned no source)`,
+        file: fromFile
+      });
+      for (const n of imp.names) deps[n.local] = void 0;
+      continue;
+    }
+    const depExports = execSidecar(
+      depSrc,
+      { loadModule: load, fromFile: canonical },
+      [...chain, canonical],
+      preloaded
+    );
+    for (const n of imp.names) {
+      if (n.ns) {
+        deps[n.local] = depExports;
+      } else if (n.imported !== void 0) {
+        if (!(n.imported in depExports)) {
+          collectDiag({
+            code: "nudo:interface-load",
+            message: `sidecar '${imp.spec}' has no export '${n.imported}'`,
+            file: fromFile
+          });
+        }
+        deps[n.local] = depExports[n.imported];
+      } else {
+        collectDiag({
+          code: "nudo:interface-load",
+          message: `sidecar default import '${n.local}' from '${imp.spec}' has no default export (sidecars export named constraints only)`,
+          file: fromFile
+        });
+        deps[n.local] = depExports.default;
+      }
+    }
+  }
+  for (const local of Object.keys(deps)) {
+    prologue.push(`var ${local} = __nudoDeps[${JSON.stringify(local)}];`);
+  }
+  const returnObj = exportPairs.map(
+    (p) => p.key === p.expr ? p.key : `${JSON.stringify(p.key)}: ${p.expr}`
+  ).join(", ");
+  const body = `${prologue.length > 0 ? `${prologue.join("\n")}
+` : ""}${code}
+return { ${returnObj} };`;
+  const fn2 = new Function(
+    ...Object.keys(sidecarInjects),
+    "__nudoInjects",
+    "__nudoDeps",
+    body
+  );
+  return fn2(...Object.values(sidecarInjects), sidecarInjects, deps);
+}
+function execNudoModule(src, opts) {
+  return execNudoModuleCached(src, opts ?? {});
+}
+var nudoModuleExecCache = /* @__PURE__ */ new Map();
+var MAX_NUDO_MODULE_EXEC = 64;
+var MAX_SIDECAR_CLOSURE = 64;
+function sidecarDepClosure(src, fromFile, loadModule, out) {
+  let ast;
+  try {
+    ast = parseSource(src);
+  } catch {
+    return { truncated: false };
+  }
+  for (const stmt of ast.program.body) {
+    if (out.size >= MAX_SIDECAR_CLOSURE) return { truncated: true };
+    if (stmt.type !== "ImportDeclaration") continue;
+    const spec = stmt.source.value;
+    if (!(spec.startsWith(".") || spec.startsWith("/"))) continue;
+    if (!isSidecarSpec(spec)) continue;
+    const canonical = resolveDepPath(fromFile, spec);
+    if (out.has(canonical)) continue;
+    const depSrc = loadModule(spec, fromFile);
+    out.set(canonical, depSrc);
+    if (depSrc === void 0) continue;
+    const r = sidecarDepClosure(depSrc, canonical, loadModule, out);
+    if (r.truncated) return r;
+  }
+  return { truncated: false };
+}
+function execNudoModuleCached(src, opts) {
+  let key;
+  let preloaded = /* @__PURE__ */ new Map();
+  if (opts.loadModule && opts.fromFile) {
+    const deps = /* @__PURE__ */ new Map();
+    const { truncated } = sidecarDepClosure(src, opts.fromFile, opts.loadModule, deps);
+    if (!truncated) {
+      const depPart = [...deps.entries()].map(([p, s]) => `${p}=${s === void 0 ? "miss" : hashSource(s)}`).sort().join(",");
+      key = `${hashSource(src)}|${depPart}`;
+      preloaded = deps;
+    }
+  } else {
+    key = src;
+  }
+  if (key !== void 0) {
+    const hit = nudoModuleExecCache.get(key);
+    if (hit !== void 0) {
+      nudoModuleExecCache.delete(key);
+      nudoModuleExecCache.set(key, hit);
+      return hit;
+    }
+  }
+  const out = execSidecar(src, opts, opts.fromFile ? [opts.fromFile] : [], preloaded);
+  if (key !== void 0) {
+    if (nudoModuleExecCache.size >= MAX_NUDO_MODULE_EXEC) {
+      const oldest = nudoModuleExecCache.keys().next().value;
+      if (oldest !== void 0) nudoModuleExecCache.delete(oldest);
+    }
+    nudoModuleExecCache.set(key, 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) {
+      collectDiag({
+        code: "nudo:interface-load",
+        message: `sidecar '${imp.spec}' not loaded: loadModule/fromFile missing from host options`,
+        file: opts.fromFile
+      });
+      continue;
+    }
+    const src = opts.loadModule(imp.spec, opts.fromFile);
+    if (src === void 0) {
+      collectDiag({
+        code: "nudo:interface-load",
+        message: `sidecar '${imp.spec}' failed to load from '${opts.fromFile}'`,
+        file: opts.fromFile
+      });
+      continue;
+    }
+    const sidecarPath = resolveDepPath(opts.fromFile, imp.spec);
+    let exports;
+    try {
+      exports = execNudoModuleCached(src, { loadModule: opts.loadModule, fromFile: sidecarPath });
+    } catch (e) {
+      if (e instanceof NudoSidecarError) {
+        collectDiag({ code: e.code, message: e.message, file: opts.fromFile });
+      } else {
+        collectDiag({
+          code: "nudo:interface-load",
+          message: `sidecar '${imp.spec}' failed to execute: ${e instanceof Error ? e.message : String(e)}`,
+          file: opts.fromFile
+        });
+      }
+      continue;
+    }
+    for (const name of imp.names) {
+      if (name.startsWith("*")) {
+        const ns = name.slice(1);
+        for (const [expName, v3] of Object.entries(exports)) {
+          if (isNudoConstraint(v3)) {
+            map.set(`${ns}.${expName}`, v3);
+          }
+        }
+        continue;
+      }
+      const v2 = exports[name];
+      if (isNudoConstraint(v2)) {
+        map.set(name, v2);
+      } else if (v2 === void 0) {
+        collectDiag({
+          code: "nudo:interface-load",
+          message: `sidecar '${imp.spec}' has no export '${name}'`,
+          file: opts.fromFile
+        });
+      } else {
+        collectDiag({
+          code: "nudo:interface-load",
+          message: `sidecar '${imp.spec}' export '${name}' is not a Nudo constraint`,
+          file: opts.fromFile
+        });
+      }
+    }
+  }
+  return map;
+}
+function extractRefineLines(source, fnName) {
+  const escaped = fnName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const fnRe = new RegExp(
+    `(?:export\\s+(?:default\\s+)?)?(?:async\\s+)?(?:function\\s+${escaped}\\b|const\\s+${escaped}\\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:contract\s+(.+)$/);
+      if (rm) reqs.unshift(rm[1].trim().replace(/\*\/$/, "").trim());
+      continue;
+    }
+    break;
+  }
+  return reqs;
+}
+function extractRefinesFromSource(source, fnName, opts = {}) {
+  if (!source.includes("@nudo:contract")) 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:contract")) 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;
+}
+function extractDeclaredThrows(source, fnName) {
+  if (!source.includes("@nudo:throws") && !source.includes("!! throws")) {
+    return void 0;
+  }
+  const kinds = /* @__PURE__ */ new Set();
+  let any2 = false;
+  const escaped = fnName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const fnRe = new RegExp(
+    `(?:export\\s+(?:default\\s+)?)?(?:async\\s+)?(?:function\\s+${escaped}\\b|const\\s+${escaped}\\s*=)`
+  );
+  const m = source.match(fnRe);
+  if (!m || m.index === void 0) return void 0;
+  const before = source.slice(0, m.index);
+  const lines = before.split("\n");
+  let seenComment = false;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (line === "") {
+      if (seenComment) break;
+      continue;
+    }
+    if (line === "*/") continue;
+    if (line.startsWith("*") || line.startsWith("/*") || line.startsWith("//")) {
+      seenComment = true;
+      const body = line.replace(/^[*/\s]+/, "").replace(/\*\/$/, "").trim();
+      const th = body.match(/@nudo:throws\s+(.+)$/i);
+      if (th) {
+        const spec = th[1].trim();
+        if (spec === "*") any2 = true;
+        else {
+          for (const k of spec.split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean)) {
+            if (k === "*") any2 = true;
+            else kinds.add(k);
+          }
+        }
+      }
+      const cs = body.match(/!!\s*throws(?:\s+([A-Za-z*][\w*|,\s]*))?/i);
+      if (cs) {
+        const spec = (cs[1] ?? "*").trim();
+        if (spec === "" || spec === "*") any2 = true;
+        else {
+          for (const k of spec.split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean)) {
+            if (k === "*") any2 = true;
+            else kinds.add(k);
+          }
+        }
+      }
+      continue;
+    }
+    break;
+  }
+  if (any2) return "*";
+  if (kinds.size > 0) return [...kinds];
+  return void 0;
+}
+
+// src/algebra/interface.ts
+var interfaceDiagCollector = null;
+var interfaceDiagSeq = 0;
+var interfaceDiags = [];
+var MAX_INTERFACE_DIAGS = 1024;
+function setInterfaceDiagCollector(fn2) {
+  interfaceDiagCollector = fn2;
+}
+function interfaceDiagCount() {
+  return interfaceDiagSeq;
+}
+function takeInterfaceDiags() {
+  const out = interfaceDiags.map((e) => e.d);
+  interfaceDiags.length = 0;
+  return out;
+}
+function takeInterfaceDiagsSince(since) {
+  const out = [];
+  let kept = 0;
+  for (const e of interfaceDiags) {
+    if (e.seq > since) out.push(e.d);
+    else interfaceDiags[kept++] = e;
+  }
+  interfaceDiags.length = kept;
+  return out;
+}
+function collectDiag2(d) {
+  if (interfaceDiags.length >= MAX_INTERFACE_DIAGS) interfaceDiags.shift();
+  interfaceDiags.push({ seq: ++interfaceDiagSeq, d });
+  interfaceDiagCollector?.(d);
+}
+function localNamedExports(source) {
+  const out = /* @__PURE__ */ new Set();
+  let ast;
+  try {
+    ast = parseSource(source, { errorRecovery: true });
+  } catch {
+    return out;
+  }
+  const importedLocalNames = /* @__PURE__ */ new Set();
+  for (const stmt of ast.program.body) {
+    if (stmt.type !== "ImportDeclaration") continue;
+    for (const spec of stmt.specifiers) {
+      if (spec.type === "ImportNamespaceSpecifier" || spec.type === "ImportDefaultSpecifier") {
+        importedLocalNames.add(spec.local.name);
+      } else if (spec.type === "ImportSpecifier") {
+        importedLocalNames.add(spec.local.name);
+      }
+    }
+  }
+  const identName = (n) => {
+    if (!n) return void 0;
+    if (n.type === "Identifier" && typeof n.name === "string") return n.name;
+    if (n.type === "Literal" && typeof n.value === "string") return n.value;
+    return void 0;
+  };
+  const localClasses = /* @__PURE__ */ new Map();
+  for (const stmt of ast.program.body) {
+    const s = stmt;
+    if (s.type !== "ClassDeclaration") continue;
+    const idName = identName(s.id);
+    if (idName) localClasses.set(idName, s);
+  }
+  const addClassMethodKeys = (out2, decl) => {
+    if (!decl || decl.type !== "ClassDeclaration") return;
+    const idName = identName(decl.id);
+    if (!idName) return;
+    const body = decl.body?.body ?? [];
+    for (const m of body) {
+      const mem = m;
+      const isMethod = mem.type === "MethodDefinition" || mem.type === "ClassMethod" || mem.type === "TSDeclareMethod";
+      if (!isMethod) continue;
+      if (mem.kind && mem.kind !== "method") continue;
+      const keyName = identName(mem.key);
+      if (keyName) out2.add(`${idName}.${keyName}`);
+    }
+  };
+  const isExportsTarget = (n) => {
+    if (!n) return false;
+    if (n.type === "Identifier") return n.name === "exports";
+    if (n.type === "MemberExpression") {
+      return identName(n.object) === "module" && n.property !== void 0 ? identName(n.property) === "exports" : false;
+    }
+    return false;
+  };
+  const cjsPropName = (left) => {
+    if (!left || left.type !== "MemberExpression") return void 0;
+    if (left.computed === true) return void 0;
+    const obj = left.object;
+    if (!isExportsTarget(obj)) return void 0;
+    return identName(left.property);
+  };
+  for (const stmt of ast.program.body) {
+    const s = stmt;
+    if (s.type === "ExportNamedDeclaration") {
+      if (s.source) continue;
+      const d = s.declaration;
+      if (!d) {
+        const specs = s.specifiers ?? [];
+        for (const spec of specs) {
+          if (spec.type !== "ExportSpecifier") continue;
+          const name = identName(spec.exported);
+          if (!name) continue;
+          const localName = identName(spec.local);
+          if (name === "default") {
+            out.add("default");
+            if (localName && !importedLocalNames.has(localName)) out.add(localName);
+            if (localName && !importedLocalNames.has(localName)) {
+              addClassMethodKeys(out, localClasses.get(localName));
+            }
+            continue;
+          }
+          if (localName && importedLocalNames.has(localName)) continue;
+          out.add(name);
+          if (localName) {
+            out.add(localName);
+            addClassMethodKeys(out, localClasses.get(localName));
+          }
+        }
+        continue;
+      }
+      if (d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") {
+        const idName = identName(d.id);
+        if (idName) out.add(idName);
+        if (d.type === "ClassDeclaration" && idName) {
+          addClassMethodKeys(out, d);
+        }
+      } else if (d.type === "VariableDeclaration") {
+        const decls = d.declarations ?? [];
+        for (const decl of decls) {
+          const idName = identName(decl.id);
+          if (idName) out.add(idName);
+        }
+      }
+      continue;
+    }
+    if (s.type === "ExportDefaultDeclaration") {
+      out.add("default");
+      const d = s.declaration;
+      if (d) {
+        if ((d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") && d.id) {
+          const idName = identName(d.id);
+          if (idName) out.add(idName);
+          if (d.type === "ClassDeclaration" && idName) {
+            addClassMethodKeys(out, d);
+          }
+        } else if (d.type === "ArrowFunctionExpression" || d.type === "FunctionExpression") {
+        } else if (d.type === "Identifier") {
+          const n = identName(d);
+          if (n && !importedLocalNames.has(n)) {
+            out.add(n);
+            addClassMethodKeys(out, localClasses.get(n));
+          }
+        }
+      }
+      continue;
+    }
+    if (s.type === "ExpressionStatement") {
+      const expr = s.expression;
+      if (!expr || expr.type !== "AssignmentExpression" || expr.operator !== "=") continue;
+      const left = expr.left;
+      const right = expr.right;
+      if (!left || !right) continue;
+      const prop = cjsPropName(left);
+      if (prop && prop !== "default") out.add(prop);
+      if (isExportsTarget(left)) {
+        if (right.type === "ObjectExpression") {
+          const props = right.properties ?? [];
+          for (const p of props) {
+            if (p.type !== "ObjectProperty" && p.type !== "Property" && p.type !== "ObjectMethod") {
+              continue;
+            }
+            const keyName = identName(p.key);
+            if (keyName && keyName !== "default") out.add(keyName);
+            else if (p.type !== "ObjectMethod") {
+              const valName = identName(p.value);
+              if (valName) out.add(valName);
+            }
+          }
+        } else if (right.type === "Identifier") {
+          const n = identName(right);
+          if (n && !importedLocalNames.has(n)) out.add(n);
+        }
+      }
+    }
+  }
+  return out;
+}
+function generatedExportNames(sidecarSrc) {
+  const out = /* @__PURE__ */ new Set();
+  let ast;
+  try {
+    ast = parseSource(sidecarSrc, { errorRecovery: true });
+  } catch {
+    return out;
+  }
+  const stmts = ast.program.body;
+  for (let i = 0; i < stmts.length; i++) {
+    const stmt = stmts[i];
+    if (stmt.type !== "ExportNamedDeclaration") continue;
+    if (stmt.source) continue;
+    const d = stmt.declaration;
+    if (!d || stmt.start == null) continue;
+    const names = [];
+    if (d.type === "VariableDeclaration") {
+      for (const decl of d.declarations) {
+        if (decl.id.type === "Identifier") names.push(decl.id.name);
+      }
+    } else if (d.type === "FunctionDeclaration" || d.type === "ClassDeclaration") {
+      if (d.id) names.push(d.id.name);
+    }
+    if (names.length === 0) continue;
+    if (regionHasGeneratedMarker(stmts, i, sidecarSrc)) {
+      for (const n of names) out.add(n);
+    }
+  }
+  return out;
+}
+function regionHasGeneratedMarker(stmts, exportIdx, src) {
+  const exportStart = stmts[exportIdx].start;
+  if (exportStart == null) return false;
+  let regionStart = 0;
+  for (let j = exportIdx - 1; j >= 0; j--) {
+    const prev = stmts[j];
+    if (prev.type === "ImportDeclaration" || prev.type === "VariableDeclaration") continue;
+    regionStart = prev.end ?? 0;
+    break;
+  }
+  return src.slice(regionStart, exportStart).split("\n").some((line) => {
+    const t = line.trim();
+    return (t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) && /@generated/.test(t);
+  });
+}
+function isUnderProjectRoot(sidecarPath, projectDir) {
+  const norm = (p) => p.split("\\").join("/").replace(/\/+$/, "");
+  const root = norm(projectDir);
+  const sc = norm(sidecarPath);
+  return sc === root || sc.startsWith(`${root}/`);
+}
+function sidecarAutoBindAllowed(sidecarPath, autoBind, projectDir) {
+  if (isNodeModulesPath(sidecarPath)) return false;
+  if (projectDir && !isUnderProjectRoot(sidecarPath, projectDir)) return false;
+  if (autoBind === void 0 || autoBind === true) return true;
+  if (typeof autoBind === "function") return autoBind(sidecarPath) === true;
+  return false;
+}
+function isDefaultExportLocal(source, localName) {
+  const reList = new RegExp(
+    `export\\s*\\{[^}]*\\b${localName}\\s+as\\s+default\\b[^}]*\\}`,
+    "m"
+  );
+  const reDefaultFn = new RegExp(
+    `export\\s+default\\s+(?:async\\s+)?function\\s+${localName}\\b`,
+    "m"
+  );
+  const reDefaultId = new RegExp(`export\\s+default\\s+${localName}\\b`, "m");
+  return reList.test(source) || reDefaultFn.test(source) || reDefaultId.test(source);
+}
+function loadSidecarBinding(source, fnName, opts) {
+  const { loadModule, fromFile, autoBind, projectDir } = opts;
+  if (!loadModule || !fromFile) return { ok: false };
+  const sidecarPath = sidecarPathOf(fromFile);
+  if (!sidecarAutoBindAllowed(sidecarPath, autoBind, projectDir)) return { ok: false };
+  if (!localNamedExports(source).has(fnName)) return { ok: false };
+  const spec = `./${sidecarPath.slice(sidecarPath.lastIndexOf("/") + 1)}`;
+  const sidecarSrc = loadModule(spec, fromFile);
+  if (sidecarSrc === void 0) return { ok: false };
+  if (sidecarSrc === source) return { ok: false };
+  let exports;
+  try {
+    exports = execNudoModule(sidecarSrc, { loadModule, fromFile: sidecarPath });
+  } catch (e) {
+    collectDiag2({
+      code: e instanceof NudoSidecarError ? e.code : "nudo:interface-load",
+      message: `sidecar '${spec}' for '${fnName}' failed: ${e instanceof Error ? e.message : String(e)}`,
+      file: sidecarPath
+    });
+    return { ok: false };
+  }
+  let binding = exports[fnName];
+  if (binding === void 0 && exports.default !== void 0 && isDefaultExportLocal(source, fnName)) {
+    binding = exports.default;
+  }
+  if (binding === void 0 && fnName.includes(".")) {
+    const [cls, method] = fnName.split(".", 2);
+    binding = exports[`${cls}_${method}`];
+    if (binding === void 0) {
+      const bag = exports[cls];
+      if (bag && typeof bag === "object" && !isNudoConstraint(bag)) {
+        binding = bag[method];
+      }
+    }
+    if (binding === void 0 && method !== void 0 && exports[method] !== void 0) {
+      collectDiag2({
+        code: "nudo:interface-load",
+        message: `sidecar key '${method}' does not bind '${fnName}' \u2014 use '${cls}.${method}', '${cls}_${method}', or nested { ${cls}: { ${method}: \u2026 } }`,
+        file: sidecarPath
+      });
+    }
+  }
+  if (binding === void 0) return { ok: false };
+  if (!isNudoConstraint(binding)) {
+    collectDiag2({
+      code: "nudo:interface-load",
+      message: `sidecar '${spec}' export '${fnName}' is not a Nudo constraint`,
+      file: sidecarPath
+    });
+    return { ok: false };
+  }
+  if (!binding.fn) {
+    collectDiag2({
+      code: "nudo:interface-load",
+      message: `sidecar '${spec}' binding '${fnName}' is not fn() form (Phase 1 consumes only fn({ \u2026 }, \u2026) bindings)`,
+      file: sidecarPath
+    });
+    return { ok: false };
+  }
+  const generatedNames = generatedExportNames(sidecarSrc);
+  const isGenerated = generatedNames.has(fnName) || (fnName.includes(".") ? (() => {
+    const [cls, method] = fnName.split(".", 2);
+    return generatedNames.has(`${cls}_${method}`) || generatedNames.has(cls);
+  })() : false);
+  return {
+    ok: true,
+    sidecarPath,
+    constraint: binding,
+    generated: isGenerated
+  };
+}
+function boundsOf(c) {
+  const out = [];
+  const visit2 = (p) => {
+    if (p.op === "and") {
+      p.args.forEach(visit2);
+      return;
+    }
+    if (p.op !== "gt" && p.op !== "ge" && p.op !== "lt" && p.op !== "le") return;
+    if (p.b.op !== "lit" || typeof p.b.value !== "number") return;
+    if (p.a.op !== "var" && p.a.op !== "app") return;
+    out.push({
+      lower: p.op === "gt" || p.op === "ge",
+      strict: p.op === "gt" || p.op === "lt",
+      n: p.b.value,
+      term: termToString(p.a)
+    });
+  };
+  c.preds.forEach(visit2);
+  return out;
+}
+function eqLitsOf(c) {
+  const out = [];
+  const visit2 = (p) => {
+    if (p.op === "and") {
+      p.args.forEach(visit2);
+      return;
+    }
+    if (p.op !== "eq") return;
+    let term;
+    let value;
+    if (p.a.op === "var" && p.b.op === "lit") {
+      term = p.a;
+      value = p.b.value;
+    } else if (p.b.op === "var" && p.a.op === "lit") {
+      term = p.b;
+      value = p.a.value;
+    }
+    if (term !== void 0 && value !== void 0) {
+      out.push({ term: termToString(term), value });
+    }
+  };
+  c.preds.forEach(visit2);
+  return out;
+}
+function boundExcludes(bounds, term, v2) {
+  for (const b of bounds) {
+    if (b.term !== term) continue;
+    if (b.lower && (b.strict ? v2 <= b.n : v2 < b.n)) return true;
+    if (!b.lower && (b.strict ? v2 >= b.n : v2 > b.n)) return true;
+  }
+  return false;
+}
+function crossBoundConflict(a, b) {
+  const A = boundsOf(a);
+  const B = boundsOf(b);
+  for (const x of A) {
+    for (const y of B) {
+      if (x.term !== y.term || x.lower === y.lower) continue;
+      const lo = x.lower ? x : y;
+      const hi = x.lower ? y : x;
+      if (lo.strict || hi.strict ? lo.n >= hi.n : lo.n > hi.n) return true;
+    }
+  }
+  const eqA = eqLitsOf(a);
+  const eqB = eqLitsOf(b);
+  for (const x of eqA) {
+    for (const y of eqB) {
+      if (x.term !== y.term) continue;
+      if (x.value !== y.value) return true;
+    }
+  }
+  for (const eq2 of eqA) {
+    if (typeof eq2.value === "number" && boundExcludes(B, eq2.term, eq2.value)) return true;
+  }
+  for (const eq2 of eqB) {
+    if (typeof eq2.value === "number" && boundExcludes(A, eq2.term, eq2.value)) return true;
+  }
+  return false;
+}
+function conjoinOrConflict(prev, next, onConflict) {
+  try {
+    return andC(prev, next);
+  } catch {
+    onConflict();
+    return prev;
+  }
+}
+function effectiveInterface(source, fnName, opts = {}) {
+  const refineSince = refineDiagCount();
+  const sourceEntries = extractRefinesFromSource(source, fnName, opts);
+  const sourceReturn = extractRefineReturnFromSource(source, fnName, opts);
+  const sourceThrows = extractDeclaredThrows(source, fnName);
+  const sidecar = loadSidecarBinding(source, fnName, opts);
+  for (const d of takeRefineDiagsSince(refineSince)) {
+    collectDiag2({ code: d.code, message: d.message, ...d.file ? { file: d.file } : {} });
+  }
+  const sidecarFn = sidecar.ok ? sidecar.constraint : void 0;
+  const sidecarGenerated = sidecar.ok && sidecar.generated;
+  const sidecarParams = sidecarFn ? fnConstraintToEntryReqs(sidecarFn) : [];
+  const sidecarReturns = sidecarFn?.fn.returns;
+  const sidecarThrowsKinds = throwConstraintToKinds(sidecarFn?.fn.throws);
+  const mergedThrows = (() => {
+    if (sourceThrows === "*" || sidecarThrowsKinds === "*") return "*";
+    const set = /* @__PURE__ */ new Set([...sourceThrows ?? [], ...sidecarThrowsKinds ?? []]);
+    return set.size > 0 ? [...set] : void 0;
+  })();
+  const hasHandwritten = sourceEntries.length > 0 || sourceReturn !== void 0 || sidecarFn !== void 0 && !sidecarGenerated;
+  if (!hasHandwritten) {
+    if (sidecarFn !== void 0 && sidecarGenerated) {
+      return {
+        fnName,
+        params: sidecarParams,
+        ...sidecarReturns !== void 0 ? { returns: { constraint: sidecarReturns } } : {},
+        ...mergedThrows !== void 0 ? { throws: { kinds: mergedThrows } } : {},
+        source: "generated"
+      };
+    }
+    return void 0;
+  }
+  const params = /* @__PURE__ */ new Map();
+  const conflictParams = [];
+  for (const e of sourceEntries) {
+    const prev = params.get(e.param);
+    if (prev === void 0) {
+      params.set(e.param, e.constraint);
+      continue;
+    }
+    if (crossBoundConflict(prev, e.constraint) && !conflictParams.includes(e.param)) {
+      conflictParams.push(e.param);
+    }
+    params.set(
+      e.param,
+      conjoinOrConflict(prev, e.constraint, () => {
+        if (!conflictParams.includes(e.param)) conflictParams.push(e.param);
+      })
+    );
+  }
+  if (sidecarFn !== void 0 && !sidecarGenerated) {
+    for (const { param, constraint } of sidecarParams) {
+      const prev = params.get(param);
+      if (prev !== void 0) {
+        if (crossBoundConflict(prev, constraint) && !conflictParams.includes(param)) {
+          conflictParams.push(param);
+        }
+        params.set(param, conjoinOrConflict(prev, constraint, () => {
+          if (!conflictParams.includes(param)) conflictParams.push(param);
+        }));
+      } else {
+        params.set(param, constraint);
+      }
+    }
+  }
+  const r1 = sourceReturn?.constraint;
+  const r2 = sidecarFn !== void 0 && !sidecarGenerated ? sidecarReturns : void 0;
+  let returnsC;
+  let conflictReturns = false;
+  if (r1 !== void 0 && r2 !== void 0) {
+    if (crossBoundConflict(r1, r2)) conflictReturns = true;
+    returnsC = conjoinOrConflict(r1, r2, () => {
+      conflictReturns = true;
+    });
+  } else {
+    returnsC = r1 ?? r2;
+  }
+  return {
+    fnName,
+    params: [...params.entries()].map(([param, constraint]) => ({ param, constraint })),
+    ...returnsC !== void 0 ? { returns: { constraint: returnsC } } : {},
+    ...mergedThrows !== void 0 ? { throws: { kinds: mergedThrows } } : {},
+    source: "handwritten",
+    ...conflictParams.length > 0 || conflictReturns ? {
+      conflict: {
+        params: conflictParams,
+        ...conflictReturns ? { returns: true } : {}
+      }
+    } : {}
+  };
+}
+var MAX_SIDECAR_FP_NODES = 64;
+function enqueueSidecarDeps(src, path, seen, queue) {
+  let ast;
+  try {
+    ast = parseSource(src);
+  } catch {
+    return;
+  }
+  for (const stmt of ast.program.body) {
+    if (stmt.type !== "ImportDeclaration") continue;
+    const spec = stmt.source.value;
+    if (!(spec.startsWith(".") || spec.startsWith("/"))) continue;
+    if (!(spec.endsWith(".nudo.js") || spec.endsWith(".nudo.ts"))) continue;
+    const depPath = resolveDepPath(path, spec);
+    if (seen.has(depPath)) continue;
+    seen.add(depPath);
+    queue.push({ spec, from: path });
+  }
+}
+function sidecarClosureFingerprint(fromFile, opts) {
+  const { loadModule, autoBind, projectDir } = opts;
+  if (!loadModule || !fromFile) return void 0;
+  const sidecarPath = sidecarPathOf(fromFile);
+  if (!sidecarAutoBindAllowed(sidecarPath, autoBind, projectDir)) return void 0;
+  const spec = `./${sidecarPath.slice(sidecarPath.lastIndexOf("/") + 1)}`;
+  const sidecarSrc = loadModule(spec, fromFile);
+  if (sidecarSrc === void 0) return void 0;
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set([sidecarPath]);
+  const queue = [];
+  enqueueSidecarDeps(sidecarSrc, sidecarPath, seen, queue);
+  let truncated = false;
+  while (queue.length > 0) {
+    if (seen.size > MAX_SIDECAR_FP_NODES) {
+      truncated = true;
+      break;
+    }
+    const { spec: s, from } = queue.shift();
+    const depPath = resolveDepPath(from, s);
+    const depSrc = loadModule(s, from);
+    parts.push(`${depPath}=${depSrc === void 0 ? "miss" : hashSource(depSrc)}`);
+    if (depSrc !== void 0) enqueueSidecarDeps(depSrc, depPath, seen, queue);
+  }
+  parts.sort();
+  const fp = `${hashSource(sidecarSrc)}|${parts.join(",")}`;
+  return truncated ? `trunc:${fp}` : fp;
+}
+function litToString(v2) {
+  if (typeof v2 === "string") return JSON.stringify(v2);
+  return String(v2);
+}
+function lengthBound(p, op) {
+  if (p.op !== op) return void 0;
+  if (p.a.op !== "app" || p.a.fn !== "length") return void 0;
+  if (p.b.op !== "lit" || typeof p.b.value !== "number") return void 0;
+  return p.b.value;
+}
+function predToChain(p) {
+  switch (p.op) {
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le": {
+      if (p.b.op !== "lit" || typeof p.b.value !== "number") break;
+      if (p.a.op === "app" && p.a.fn === "length") {
+        if (p.op === "ge") return `.min(${p.b.value})`;
+        if (p.op === "le") return `.max(${p.b.value})`;
+        break;
+      }
+      if (p.a.op === "var") return `.${p.op}(${p.b.value})`;
+      break;
+    }
+    case "eq": {
+      if (p.b.op === "lit" && p.a.op === "var") return `.eq(${litToString(p.b.value)})`;
+      break;
+    }
+    case "and": {
+      if (p.args.length === 2) {
+        const [a, b] = [p.args[0], p.args[1]];
+        for (const [x, y] of [
+          [a, b],
+          [b, a]
+        ]) {
+          const ge2 = lengthBound(x, "ge");
+          const le2 = lengthBound(y, "le");
+          if (ge2 !== void 0 && ge2 === le2) return `.length(${ge2})`;
+        }
+      }
+      return p.args.map(predToChain).join("");
+    }
+    default:
+      break;
+  }
+  return `{${predToString(p)}}`;
+}
+function fmtConstraint(c) {
+  if (c.fn) {
+    const args = [
+      `{ ${Object.entries(c.fn.params).map(([k, v2]) => `${k}: ${fmtConstraint(v2)}`).join(", ")} }`
+    ];
+    if (c.fn.returns !== void 0) args.push(fmtConstraint(c.fn.returns));
+    if (c.fn.throws !== void 0) args.push(`{ throws: ${fmtConstraint(c.fn.throws)} }`);
+    return `fn(${args.join(", ")})`;
+  }
+  if (c.members) return `union(${c.members.map(fmtConstraint).join(", ")})`;
+  if (c.fields) {
+    const fs = Object.entries(c.fields).map(([k, f]) => {
+      const opt = f.optional || f.constraint.isOptional ? "?" : "";
+      return `${k}${opt}: ${fmtConstraint(f.constraint)}`;
+    });
+    return `shape({ ${fs.join(", ")} })`;
+  }
+  if (c.element) return `array(${fmtConstraint(c.element)})`;
+  if (c.preds.length === 1 && c.preds[0].op === "eq" && c.preds[0].a.op === "var" && c.preds[0].b.op === "lit" && !isIntFlag(c)) {
+    return `lit(${litToString(c.preds[0].b.value)})`;
+  }
+  let out = c.prim !== void 0 ? `${c.prim}()` : c.preds.length > 0 ? "number()" : "any()";
+  if (isIntFlag(c)) out += ".int()";
+  for (const p of c.preds) out += predToChain(p);
+  if (c.isOptional) out += ".optional()";
+  return out;
+}
+function formatConstraint(c) {
+  return fmtConstraint(c);
+}
+function formatEffectiveInterfaceDisplay(eff) {
+  const params = eff.params.map((p) => `${p.param}: ${formatConstraint(p.constraint)}`).join(", ");
+  let s = `(${params})`;
+  if (eff.returns) s += ` \u2192 ${formatConstraint(eff.returns.constraint)}`;
+  return s;
+}
+function formatInterfaceTierLine(source) {
+  return `\u25CF interface / ${source}`;
+}
+function interfaceTierOf(source, fnName, fromFile, opts = {}) {
+  if (!localNamedExports(source).has(fnName)) return void 0;
+  const eff = effectiveInterface(source, fnName, { fromFile, ...opts });
+  const src = eff?.source ?? "implicit";
+  if (eff && src !== "implicit") {
+    return { source: src, display: formatEffectiveInterfaceDisplay(eff) };
+  }
+  return { source: src };
+}
+function interfaceSourceOf(source, fnName, fromFile, opts = {}) {
+  return interfaceTierOf(source, fnName, fromFile, opts)?.source;
+}
+
+// src/algebra/fn-fp.ts
+var fnFpCache = /* @__PURE__ */ new Map();
+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 obj = node;
+  if (obj.type === "Identifier" && typeof obj.name === "string" && known.has(obj.name)) {
+    out.add(obj.name);
+  }
+  for (const key of Object.keys(obj)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") {
+      continue;
+    }
+    if ((key === "key" || key === "property") && (obj.type === "MemberExpression" || obj.type === "ObjectProperty" || obj.type === "ObjectMethod" || obj.type === "ClassMethod" || obj.type === "ClassProperty") && obj.computed !== true) {
+      continue;
+    }
+    if (key === "id" && (obj.type === "FunctionDeclaration" || obj.type === "FunctionExpression" || obj.type === "ClassDeclaration" || obj.type === "ClassExpression")) {
+      continue;
+    }
+    const v2 = obj[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 obj = node;
+  if (obj.type === "CallExpression" || obj.type === "NewExpression" || obj.type === "OptionalCallExpression" || obj.type === "ImportExpression") {
+    return true;
+  }
+  for (const key of Object.keys(obj)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") {
+      continue;
+    }
+    const v2 = obj[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:contract")) 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 extractAllLoadSpecs(source) {
+  const specs = /* @__PURE__ */ new Set();
+  for (const imp of extractNudoImports(source)) specs.add(imp.spec);
+  const isPathLikeSpec = (spec) => spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/") || /\.(ts|js|mjs|cjs|tsx|jsx)$/.test(spec);
+  const envRe = /@nudo:env\s+([^\n*]+)/g;
+  let envM;
+  while (envM = envRe.exec(source)) {
+    for (const part of envM[1].split(",")) {
+      const spec = part.trim().replace(/^['"]|['"]$/g, "");
+      if (spec && isPathLikeSpec(spec)) specs.add(spec);
+    }
+  }
+  const mockFromRe = /@nudo:mock-module\s+"[^"]+"\s+(?:\{[^}]*\}\s+)?from\s+["']([^"']+)["']/g;
+  let mockM;
+  while (mockM = mockFromRe.exec(source)) specs.add(mockM[1]);
+  const patterns = [
+    /\bfrom\s*['"]([^'"]+)['"]/g,
+    /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+  ];
+  for (const re of patterns) {
+    let m;
+    while (m = re.exec(source)) specs.add(m[1]);
+  }
+  return [...specs];
+}
+function sidecarSpecsOf(source) {
+  return extractAllLoadSpecs(source).filter(
+    (spec) => (spec.startsWith(".") || spec.startsWith("/")) && (spec.endsWith(".nudo.js") || spec.endsWith(".nudo.ts"))
+  );
+}
+function loadModuleDepsFingerprint(source, loadModule, fromFile) {
+  const parts = [];
+  const paths = [];
+  const contents = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = extractAllLoadSpecs(source).map(
+    (spec) => ({ spec, from: fromFile })
+  );
+  let n = 0;
+  let truncated = false;
+  const finish = () => {
+    parts.sort();
+    return truncated ? { fp: `trunc:${parts.join(",")}`, paths, contents, truncated: true } : { fp: parts.join(","), paths, contents, truncated: false };
+  };
+  const absorbSidecarClosure = (entryFile) => {
+    const sidecarPath = sidecarPathOf(entryFile);
+    if (seen.has(sidecarPath)) return;
+    const sidecarSpec = `./${sidecarPath.slice(sidecarPath.lastIndexOf("/") + 1)}`;
+    const sidecarSrc = loadModule(sidecarSpec, entryFile);
+    if (sidecarSrc === void 0) return;
+    if (n >= MAX_LOAD_DEP_NODES) {
+      truncated = true;
+      return;
+    }
+    seen.add(sidecarPath);
+    n++;
+    parts.push(`sidecar:${sidecarPath}=${hashSource(sidecarSrc)}`);
+    paths.push(sidecarPath);
+    contents.push({ path: sidecarPath, content: sidecarSrc });
+    const sidecarQueue = sidecarSpecsOf(
+      sidecarSrc
+    ).map((spec) => ({ spec, from: sidecarPath }));
+    while (sidecarQueue.length > 0) {
+      if (n >= MAX_LOAD_DEP_NODES) {
+        truncated = true;
+        return;
+      }
+      const cur = sidecarQueue.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(`sidecar:${path}=${src === void 0 ? "miss" : hashSource(src)}`);
+      paths.push(path);
+      contents.push({ path, content: src ?? null });
+      if (src === void 0) continue;
+      for (const next of sidecarSpecsOf(src)) {
+        const nextPath = resolveDepPath(path, next);
+        if (!seen.has(nextPath)) sidecarQueue.push({ spec: next, from: path });
+      }
+    }
+  };
+  while (queue.length > 0) {
+    if (n >= MAX_LOAD_DEP_NODES) {
+      truncated = true;
+      break;
+    }
+    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);
+    contents.push({ path, content: src ?? null });
+    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 });
+    }
+    absorbSidecarClosure(path);
+  }
+  absorbSidecarClosure(fromFile);
+  return finish();
+}
+
+// src/algebra/generalize-key.ts
+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 collectAbsFreeVars(a) {
+  const acc = /* @__PURE__ */ new Set();
+  collectAbsVars(a, acc, /* @__PURE__ */ new Set());
+  return acc;
+}
+function renameTerm(t, map) {
+  if (t.op === "var") {
+    const to = map.get(t.id);
+    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);
+}
+
+// src/algebra/promote-scan.ts
+var HOF_ARR_METHODS = /* @__PURE__ */ new Set(["map", "filter", "reduce", "flatMap"]);
+function alphaOfTerm(t, ctx) {
+  if (t?.op === "var" && ctx.alphaIds.has(t.id)) return t;
+  ctx.freshSeq.n += 1;
+  const id = `T${ctx.freshSeq.n}`;
+  ctx.alphaIds.add(id);
+  return v(id);
+}
+function rawTermOf(arg, ctx) {
+  if (arg?.type === "Identifier") {
+    const lt2 = ctx.localTerms.get(arg.name);
+    if (lt2) return lt2;
+    if (ctx.paramTermId.has(arg.name)) {
+      return v(ctx.paramTermId.get(arg.name));
+    }
+  }
+  if (arg?.type === "NumericLiteral") return { op: "lit", value: arg.value };
+  if (arg?.type === "StringLiteral") return { op: "lit", value: arg.value };
+  if (arg?.type === "BooleanLiteral") return { op: "lit", value: arg.value };
+  return { op: "var", id: "_" };
+}
+function alphaTermOf(arg, ctx) {
+  if (arg?.type === "Identifier") {
+    const lt2 = ctx.localTerms.get(arg.name);
+    if (lt2) return lt2;
+    if (ctx.paramTermId.has(arg.name)) {
+      return v(ctx.paramTermId.get(arg.name));
+    }
+  }
+  return alphaOfTerm(void 0, ctx);
+}
+function promoteShape(ctx, param, shape2, loc, recordSite = true) {
+  const prev = ctx.shapes.get(param);
+  if (!prev) return;
+  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") return;
+  const next = { shape: shape2, term: prev.term, pred: prev.pred, conf: "path" };
+  ctx.shapes.set(param, next);
+  ctx.promotedShapes.set(param, shape2);
+  if (shape2.k === "fn") {
+    if (!ctx.fnRels.has(param) && !ctx.entryShapes.has(param)) {
+      ctx.fnRels.set(param, { abs: { ...next }, source: "promote" });
+    }
+    if (recordSite) {
+      ctx.sites.push({
+        param,
+        argTerms: [],
+        result: shape2.returnType ?? next,
+        loc
+      });
+    }
+  } else {
+    if (!ctx.fnRels.has(param) && !ctx.entryShapes.has(param)) {
+      ctx.entryShapes.set(param, { abs: { ...next }, source: "promote" });
+    }
+  }
+}
+function promoteAsArr(ctx, name, loc) {
+  if (!ctx.params.has(name)) return;
+  const prev = ctx.shapes.get(name);
+  if (!prev) return;
+  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") return;
+  const element = prev.term ? abs(prev.shape, prev.term, prev.pred, "path") : abs({ k: "any" }, void 0, void 0, "path");
+  promoteShape(ctx, name, { k: "arr", element }, loc);
+}
+function promoteAsFn(ctx, name, args, loc) {
+  if (!ctx.params.has(name)) return;
+  const prev = ctx.shapes.get(name);
+  if (!prev) return;
+  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") {
+    if (prev.shape.k === "fn") {
+      ctx.sites.push({
+        param: name,
+        argTerms: args.map((a) => rawTermOf(a, ctx)),
+        result: prev.shape.returnType ?? prev,
+        loc
+      });
+    }
+    return;
+  }
+  const beta = v(`B:${name}`);
+  const paramTypes = args.map((a) => abs({ k: "any" }, alphaTermOf(a, ctx), void 0, "path"));
+  const ret = abs({ k: "any" }, beta, void 0, "path");
+  const fnShape = {
+    k: "fn",
+    params: args.map((_, i) => `x${i}`),
+    paramTypes,
+    returnType: ret
+  };
+  promoteShape(ctx, name, fnShape, loc, false);
+  ctx.sites.push({
+    param: name,
+    argTerms: args.map((a) => rawTermOf(a, ctx)),
+    result: ret,
+    loc
+  });
+}
+function promoteCb(ctx, cbName, method, argTerms, loc) {
+  if (!ctx.params.has(cbName)) return;
+  const prev = ctx.shapes.get(cbName);
+  if (!prev) return;
+  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") return;
+  let paramTypes;
+  let returnType;
+  if (method === "filter") {
+    paramTypes = argTerms.map((t) => abs({ k: "any" }, t, void 0, "path"));
+    returnType = abs({ k: "prim", type: "boolean" }, void 0, void 0, "path");
+  } else {
+    paramTypes = argTerms.map((t) => abs({ k: "any" }, t, void 0, "path"));
+    returnType = abs({ k: "any" }, v(`B:${cbName}`), void 0, "path");
+  }
+  const fnShape = {
+    k: "fn",
+    params: argTerms.map((_, i) => `x${i}`),
+    paramTypes,
+    returnType
+  };
+  promoteShape(ctx, cbName, fnShape, loc, false);
+  ctx.sites.push({
+    param: cbName,
+    argTerms,
+    result: returnType,
+    loc
+  });
+}
+function locOf(n) {
+  const l = n.loc;
+  return l ? { line: l.start.line, column: l.start.column } : void 0;
+}
+function visit(node, ctx) {
+  if (!node || typeof node !== "object") return;
+  const n = node;
+  if (n.type === "FunctionDeclaration" || n.type === "ClassDeclaration") return;
+  switch (n.type) {
+    case "CallExpression": {
+      const callee = n.callee;
+      const args = n.arguments ?? [];
+      if (callee.type === "MemberExpression" && callee.computed !== true) {
+        const prop = callee.property;
+        const method = prop?.name;
+        if (method) {
+          if (callee.object?.type === "Identifier" && HOF_ARR_METHODS.has(method)) {
+            promoteAsArr(ctx, callee.object.name, locOf(node));
+          }
+          if (HOF_ARR_METHODS.has(method)) {
+            const cb = args[0];
+            if (cb?.type === "Identifier" && ctx.params.has(cb.name)) {
+              const elemTerm = callee.object?.type === "Identifier" && ctx.paramTermId.has(callee.object.name) ? v(ctx.paramTermId.get(callee.object.name)) : alphaOfTerm(void 0, ctx);
+              if (method === "reduce") {
+                promoteCb(ctx, cb.name, "reduce", [alphaTermOf(args[1], ctx), elemTerm], locOf(node));
+              } else {
+                promoteCb(ctx, cb.name, method, [elemTerm], locOf(node));
+              }
+            }
+          }
+        }
+      } else if (callee.type === "Identifier") {
+        promoteAsFn(ctx, callee.name, args, locOf(node));
+      }
+      break;
+    }
+    case "ForOfStatement": {
+      const right = n.right;
+      let saved;
+      let bindName;
+      if (right?.type === "Identifier" && ctx.paramTermId.has(right.name)) {
+        promoteAsArr(ctx, right.name, locOf(node));
+        const left = n.left;
+        const bind = left?.type === "VariableDeclaration" ? left.declarations?.[0]?.id?.name : left?.type === "Identifier" ? left.name : void 0;
+        if (bind) {
+          bindName = bind;
+          saved = ctx.localTerms.get(bind);
+          ctx.localTerms.set(bind, v(ctx.paramTermId.get(right.name)));
+        }
+      }
+      for (const key of Object.keys(n)) {
+        if (key === "loc" || key === "start" || key === "end") continue;
+        const v2 = n[key];
+        if (Array.isArray(v2)) {
+          for (const item of v2) {
+            if (item && typeof item === "object" && "type" in item) visit(item, ctx);
+          }
+        } else if (v2 && typeof v2 === "object" && "type" in v2) {
+          visit(v2, ctx);
+        }
+      }
+      if (bindName !== void 0) {
+        if (saved !== void 0) ctx.localTerms.set(bindName, saved);
+        else ctx.localTerms.delete(bindName);
+      }
+      return;
+    }
+    default:
+      break;
+  }
+  for (const key of Object.keys(n)) {
+    if (key === "loc" || key === "start" || key === "end") continue;
+    const v2 = n[key];
+    if (Array.isArray(v2)) {
+      for (const item of v2) {
+        if (item && typeof item === "object" && "type" in item) visit(item, ctx);
+      }
+    } else if (v2 && typeof v2 === "object" && "type" in v2) {
+      visit(v2, ctx);
+    }
+  }
+}
+function scanPromotions(body, params, paramTermIds, initialShapes) {
+  const res = {
+    promotedShapes: /* @__PURE__ */ new Map(),
+    fnRels: /* @__PURE__ */ new Map(),
+    entryShapes: /* @__PURE__ */ new Map(),
+    sites: []
+  };
+  const ctx = {
+    params: new Set(params),
+    paramTermId: new Map(params.map((p, i) => [p, paramTermIds[i] ?? `A${i + 1}`])),
+    shapes: new Map(initialShapes),
+    promotedShapes: res.promotedShapes,
+    localTerms: /* @__PURE__ */ new Map(),
+    freshSeq: { n: 0 },
+    alphaIds: new Set(paramTermIds),
+    fnRels: res.fnRels,
+    entryShapes: res.entryShapes,
+    sites: res.sites
+  };
+  visit(body, ctx);
+  return res;
+}
+
+// src/algebra/generalize.ts
+var bRunMemo = /* @__PURE__ */ new Map();
+function bPathRunOf(source, modules, inject) {
+  const mKey = `${source}|${runTranspiledOptionsMemoKey({ ...inject ?? {}, ...modules ? { modules } : {} })}`;
+  if (bRunMemo.size >= 256) {
+    const oldest = bRunMemo.keys().next().value;
+    if (oldest !== void 0) bRunMemo.delete(oldest);
+  }
+  let run = bRunMemo.get(mKey);
+  if (run === void 0) {
+    const merged = modules ?? inject?.modules;
+    const r = tryRunTranspiled(source, {
+      ...inject ?? {},
+      mode: "analyze",
+      ...merged ? { modules: merged } : {}
+    });
+    if (r === void 0) return void 0;
+    run = r;
+    bRunMemo.set(mKey, run);
+  }
+  return run;
+}
+function ctorParamCountOf(fileAst, clsName) {
+  for (const stmt of fileAst.program.body) {
+    if ((stmt.type === "ClassDeclaration" || stmt.type === "ExportNamedDeclaration") && "declaration" in stmt) {
+      const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
+      const c = decl;
+      if (c.type === "ClassDeclaration" && c.id?.name === clsName) {
+        for (const m of c.body?.body ?? []) {
+          const mem = m;
+          if (mem.kind === "constructor") return mem.params?.length ?? 0;
+        }
+        return 0;
+      }
+    }
+  }
+  return 0;
+}
+function bodyReferencesName(body, name) {
+  let found = false;
+  const visit2 = (n) => {
+    if (found || !n || typeof n !== "object") return;
+    const o = n;
+    if (o.type === "Identifier" && o.name === name) {
+      found = true;
+      return;
+    }
+    for (const key of Object.keys(o)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "tokens") continue;
+      if (o.type === "MemberExpression" && key === "property" && o.computed !== true) {
+        continue;
+      }
+      const v2 = o[key];
+      if (Array.isArray(v2)) {
+        for (const item of v2) if (item && typeof item === "object") visit2(item);
+      } else if (v2 && typeof v2 === "object") {
+        visit2(v2);
+      }
+    }
+  };
+  visit2(body);
+  return found;
+}
+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(fn2) {
+  if (!fn2) return 0;
+  let id = loadModuleIds.get(fn2);
+  if (id === void 0) {
+    id = nextLoadModuleId++;
+    loadModuleIds.set(fn2, id);
+  }
+  return id;
+}
+function refineDepsFingerprint(source, refine) {
+  if (!refine?.loadModule || !refine.fromFile) {
+    return { fp: "-", paths: [], contents: [], truncated: false };
+  }
+  return loadModuleDepsFingerprint(source, refine.loadModule, refine.fromFile);
+}
+var moduleMapIds = /* @__PURE__ */ new WeakMap();
+var moduleMapIdSeq = 0;
+function moduleMapId(m) {
+  if (!m) return "-";
+  let id = moduleMapIds.get(m);
+  if (id === void 0) {
+    id = ++moduleMapIdSeq;
+    moduleMapIds.set(m, id);
+  }
+  return `m${id}`;
+}
+function generalizeMemoKey(fnName, source, opts) {
+  const r = opts.refine;
+  const budget = opts.budget ?? defaultLeakBudget;
+  const deps = opts.depsFp ?? (r ? refineDepsFingerprint(source, r) : { fp: "-", paths: [], contents: [], truncated: false });
+  const sc = opts.sidecarFp ?? (r?.loadModule && r.fromFile ? sidecarClosureFingerprint(r.fromFile, r) : void 0);
+  const scPath = sc !== void 0 && !sc.startsWith("trunc:") && r?.fromFile ? normPath(sidecarPathOf(r.fromFile)) : void 0;
+  const srcPart = generalizeSourceKeyPart(source, fnName, opts.file);
+  const key = [
+    srcPart,
+    fnName,
+    opts.label ?? "A",
+    r ? `${loadModuleId(r.loadModule)}:${r.fromFile ?? ""}` : "-",
+    deps.fp,
+    sc ?? "-",
+    `${budget.maxDepth}/${budget.maxNodes}`,
+    moduleMapId(opts.modules),
+    runTranspiledOptionsMemoKey(opts.inject)
+  ].join("|");
+  return {
+    key,
+    depPaths: scPath !== void 0 ? [...deps.paths, scPath] : deps.paths,
+    truncated: deps.truncated || (sc?.startsWith("trunc:") ?? false)
+  };
+}
+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 extractFn(source, fnName, fileAst) {
+  const file = fileAst ?? parseSource(source);
+  const env = emptyEnv();
+  const formalsByName = /* @__PURE__ */ new Map();
+  for (const stmt of file.program.body) {
+    let decl = stmt;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      const formals = formalParamsFromNodes(decl.params);
+      env.fns.set(decl.id.name, {
+        params: formalParamDisplayNames(formals),
+        body: decl.body,
+        async: decl.async === true
+      });
+      formalsByName.set(decl.id.name, formals);
+      if (stmt.type === "ExportDefaultDeclaration") {
+        env.fns.set("default", env.fns.get(decl.id.name));
+        formalsByName.set("default", formals);
+      }
+    }
+    if (decl.type === "ClassDeclaration" && decl.id?.name) {
+      const cname = decl.id.name;
+      const body = decl.body?.body ?? [];
+      for (const m of body) {
+        const mem = m;
+        const isMethod = mem.type === "MethodDefinition" || mem.type === "ClassMethod" || mem.type === "TSDeclareMethod";
+        if (!isMethod || !mem.body) continue;
+        if (mem.kind && mem.kind !== "method") continue;
+        const keyName = mem.key?.type === "Identifier" ? mem.key.name : void 0;
+        if (!keyName) continue;
+        const fullName = `${cname}.${keyName}`;
+        const formals = formalParamsFromNodes(mem.params ?? []);
+        env.fns.set(fullName, {
+          params: formalParamDisplayNames(formals),
+          body: mem.body,
+          async: mem.async === true
+        });
+        formalsByName.set(fullName, formals);
+      }
+    }
+    if (decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        if (d.id.type === "Identifier" && d.init && (d.init.type === "ArrowFunctionExpression" || d.init.type === "FunctionExpression")) {
+          const init = d.init;
+          const formals = formalParamsFromNodes(init.params);
+          env.fns.set(d.id.name, {
+            params: formalParamDisplayNames(formals),
+            body: init.body,
+            async: init.async === true
+          });
+          formalsByName.set(d.id.name, formals);
+        }
+      }
+    }
+    if (stmt.type === "ExportDefaultDeclaration" && (decl.type === "ArrowFunctionExpression" || decl.type === "FunctionExpression" || decl.type === "FunctionDeclaration" && !decl.id)) {
+      const init = decl;
+      const formals = formalParamsFromNodes(init.params);
+      env.fns.set("default", {
+        params: formalParamDisplayNames(formals),
+        body: init.body,
+        async: init.async === true
+      });
+      formalsByName.set("default", formals);
+    }
+  }
+  const registerFnNode = (key, node) => {
+    if (!node?.body) return;
+    if (node.type !== "FunctionExpression" && node.type !== "ArrowFunctionExpression" && node.type !== "ObjectMethod" && node.type !== "ClassMethod" && node.type !== "FunctionDeclaration") {
+      return;
+    }
+    const formals = formalParamsFromNodes(node.params ?? []);
+    env.fns.set(key, {
+      params: formalParamDisplayNames(formals),
+      body: node.body,
+      async: node.async === true
+    });
+    formalsByName.set(key, formals);
+  };
+  const ident = (n) => {
+    const id = n;
+    if (!id) return void 0;
+    if (id.type === "Identifier" && typeof id.name === "string") return id.name;
+    if (id.type === "StringLiteral" || id.type === "NumericLiteral") return String(id.value);
+    return void 0;
+  };
+  const isExportsTarget = (n) => {
+    const id = n;
+    if (!id) return false;
+    if (id.type === "Identifier") return id.name === "exports" || id.name === "module";
+    if (id.type === "MemberExpression") {
+      return id.object?.name === "module" && id.property?.name === "exports";
+    }
+    return false;
+  };
+  for (const stmt of file.program.body) {
+    if (stmt.type !== "ExpressionStatement") continue;
+    const expr = stmt.expression;
+    if (!expr || expr.type !== "AssignmentExpression" || expr.operator !== "=") continue;
+    const left = expr.left;
+    const right = expr.right;
+    if (!left || !right) continue;
+    const propName = left.property ? ident(left.property) : void 0;
+    const isModuleExportsIdent = left.type === "MemberExpression" && left.object?.name === "module" && left.property?.name === "exports" || left.type === "Identifier" && left.name === "exports";
+    const isExportsMember = left.type === "MemberExpression" && left.object && (left.object.name === "exports" || left.object.object?.name === "module" && left.object.property?.name === "exports");
+    if (isModuleExportsIdent) {
+      if (right.type === "ObjectExpression") {
+        for (const p of right.properties ?? []) {
+          const prop = p;
+          const keyName = ident(prop.key);
+          if (!keyName) continue;
+          if (prop.type === "ObjectMethod" || prop.type === "ClassMethod") {
+            registerFnNode(keyName, prop);
+          } else {
+            registerFnNode(keyName, prop.value);
+          }
+        }
+      } else if (right.type === "Identifier") {
+        const n = ident(right);
+        if (n) {
+        }
+      } else {
+        registerFnNode("default", right);
+      }
+      continue;
+    }
+    if (isExportsMember && propName) {
+      registerFnNode(propName, right);
+    }
+  }
+  const fn2 = env.fns.get(fnName);
+  if (!fn2) return void 0;
+  return { params: fn2.params, body: fn2.body, env, formals: formalsByName.get(fnName) ?? [] };
+}
+function generalizeFromAst(fnName, source, opts = {}) {
+  const { key, depPaths, truncated } = generalizeMemoKey(fnName, source, opts);
+  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, formals } = 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 r = opts.refine;
+      const hasDirective = source.includes("@nudo:contract") || source.includes("@nudo:contract");
+      const sc = opts.sidecarFp ?? (r.loadModule && r.fromFile ? sidecarClosureFingerprint(r.fromFile, r) : void 0);
+      const eff = hasDirective || sc !== void 0 ? effectiveInterface(source, fnName, r) : void 0;
+      const reqs = eff?.params ?? [];
+      if (reqs.length > 0) {
+        entryReqs = reqs.map((e) => ({
+          param: e.param,
+          pred: instantiateConstraint(e.constraint, e.param)
+        }));
+        for (const e of reqs) {
+          const idx = params.indexOf(e.param);
+          if (idx >= 0) {
+            const entryAbs = constraintToEntryAbs(e.constraint, e.param);
+            typeParams[idx] = {
+              id: typeParams[idx].id,
+              value: entryAbs
+            };
+            refineEntryShapes.set(e.param, {
+              abs: snapshotAbs(entryAbs),
+              source: "refine"
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const instMemo = /* @__PURE__ */ new Map();
+  const alphaIds = typeParams.map((t) => t.id);
+  const promoteScan = scanPromotions(
+    body,
+    params,
+    typeParams.map((t) => t.id),
+    new Map(params.map((p, i) => [p, typeParams[i].value]))
+  );
+  const fileAst = opts.file ?? parseSource(source);
+  const importSpecByLocal = /* @__PURE__ */ new Map();
+  for (const stmt of fileAst.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      for (const s of stmt.specifiers) {
+        importSpecByLocal.set(s.local.name, stmt.source.value ?? "");
+      }
+    }
+  }
+  const unresolvableImports = [...importSpecByLocal.keys()].some((n) => {
+    if (!bodyReferencesName(body, n)) return false;
+    const spec = importSpecByLocal.get(n);
+    return spec === void 0 || !(opts.modules && Object.prototype.hasOwnProperty.call(opts.modules, spec));
+  });
+  const inject = opts.inject;
+  const hasMocks = inject && Object.keys(inject.mocks ?? {}).length > 0;
+  const hasEnv = inject && Object.keys(inject.envGlobals ?? {}).length > 0;
+  const hasReps = inject && Object.keys(inject.replacements ?? {}).length > 0;
+  const hasFnMockDirective = /@nudo:mock\s+\w+\s*(?:=|from\b)/.test(source);
+  const hasModMockDirective = /@nudo:mock-module\b/.test(source);
+  const hasModInject = inject && inject.modules && Object.keys(inject.modules).length > 0;
+  const mockGated = hasFnMockDirective && !hasMocks || hasModMockDirective && !hasModInject;
+  const envGatedSource = /@nudo:env\b/.test(source) && !hasEnv;
+  const boundNames = formals.flatMap(
+    (f) => f.kind === "pattern" ? f.bound : [f.name]
+  );
+  const envGated = envGatedSource && freeIdentifiers(body, boundNames).size > 0;
+  const replaceGated = /@nudo:replace\b/.test(source) && !hasReps;
+  const bEligible = !unresolvableImports && !mockGated && !envGated && !replaceGated;
+  const run = (args, phi = pTrue) => {
+    const { key, varOrder } = instantiateMemoKey(args, phi);
+    const hit = instMemo.get(key);
+    if (hit !== void 0) {
+      return alphaRenameResult(hit.result, hit.varOrder, varOrder);
+    }
+    let result;
+    if (bEligible) {
+      try {
+        const bRun = bPathRunOf(source, opts.modules, opts.inject);
+        if (!bRun) {
+        } else if (fnName.includes(".")) {
+          const [clsName, methodName] = fnName.split(".", 2);
+          const clsAbs = bRun[clsName ?? ""];
+          if (clsAbs && typeof clsAbs === "object" && "shape" in clsAbs) {
+            const nCtor = ctorParamCountOf(fileAst, clsName ?? "");
+            const inst = $new(clsAbs, Array.from({ length: nCtor }, () => abs({ k: "any" }, void 0, pTrue, "path")));
+            result = withExecPhi(phi, () => $invoke(inst, methodName ?? "", args));
+          }
+        } else if (fnName in bRun) {
+          const bArgs = args.map((a, i) => {
+            const shape2 = promoteScan.promotedShapes.get(params[i]);
+            if (shape2 && (a.shape.k === "any" || a.shape.k === "unknown")) {
+              return { shape: shape2, term: a.term, pred: a.pred, conf: "path" };
+            }
+            return a;
+          });
+          result = callTranspiledExportFull(bRun, fnName, bArgs, { phi }).result;
+        }
+      } catch {
+      }
+    }
+    if (result === void 0) {
+      result = abs({ k: "unknown" }, void 0, void 0, "opaque");
+    }
+    if (isCacheableAbs(result)) {
+      instMemo.set(key, { result, varOrder });
+    }
+    return result;
+  };
+  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
+  );
+  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 promoteScan.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 promoteScan.entryShapes) {
+      if (refineEntryShapes.has(param)) continue;
+      if (!entryShapes) entryShapes = /* @__PURE__ */ new Map();
+      entryShapes.set(param, { abs: snapshotAbs(rec.abs), source: rec.source });
+    }
+    if (promoteScan.sites.length > 0) {
+      hofSites = promoteScan.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
+    ),
+    ...formals.length > 0 ? { formals } : {},
+    ...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 predPart = symbolic.pred && symbolic.pred.op !== "true" ? `  where ${predToString(symbolic.pred)}` : "";
+  return `${name}: (${ps}) => ${ret}${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 = [];
+  const push = (n) => {
+    if (n && !names.includes(n)) names.push(n);
+  };
+  const walk = (decl, stmtType) => {
+    if (!decl) return;
+    if (decl.type === "FunctionDeclaration") {
+      const id = decl.id;
+      if (id?.name) push(id.name);
+      else if (stmtType === "ExportDefaultDeclaration") push("default");
+      return;
+    }
+    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")) {
+          push(d.id.name);
+        }
+      }
+      return;
+    }
+    if (decl.type === "ArrowFunctionExpression" || decl.type === "FunctionExpression") {
+      push("default");
+    }
+  };
+  for (const stmt of file.program.body) {
+    if (stmt.type === "FunctionDeclaration" || stmt.type === "VariableDeclaration") {
+      walk(stmt, stmt.type);
+      continue;
+    }
+    if (stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration") {
+      walk(stmt.declaration, stmt.type);
+    }
+  }
+  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: "any" }, void 0, void 0, "path");
+  });
+}
+
+// src/algebra/domain-membership.ts
+function literalMeetsConstraint(lv, c) {
+  const ext = c;
+  if (c.fields || c.element) return false;
+  if (ext.fn) return false;
+  if (Array.isArray(ext.members) && ext.members.length > 0) {
+    return ext.members.some((m) => literalMeetsConstraint(lv, m));
+  }
+  if (c.prim === void 0) {
+    return c.preds.every((p) => predHolds(lv, p));
+  }
+  if (!primMatches(c.prim, lv)) return false;
+  if (isIntFlag(c) && c.prim === "number" && !(typeof lv === "number" && Number.isInteger(lv))) {
+    return false;
+  }
+  return c.preds.every((p) => predHolds(lv, p));
+}
+function primMatches(prim, lv) {
+  switch (prim) {
+    case "number":
+      return typeof lv === "number";
+    case "string":
+      return typeof lv === "string";
+    case "boolean":
+      return typeof lv === "boolean";
+    case "object":
+      return lv === null;
+    default:
+      return false;
+  }
+}
+function predHolds(lv, p) {
+  switch (p.op) {
+    case "eq": {
+      const v2 = selfEqLiteral(p);
+      return v2 !== void 0 && lv === v2;
+    }
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+      return boundHolds(lv, p);
+    case "typeof":
+      return p.t.op === "var" && p.t.id === SELF && primMatches(p.type, lv);
+    // and 是合取：逐参数按同一规则判定（string().length(n) 的 preds 是
+    // and 包裹的两个长度界，叶子仍是 gt/ge/lt/le，无假阳性风险）
+    case "and":
+      return p.args.every((x) => predHolds(lv, x));
+    // ne / or / not / true / false 等其余形态：保守不满足
+    default:
+      return false;
+  }
+}
+function selfEqLiteral(p) {
+  if (isSelfVar(p.a) && p.b.op === "lit") return p.b.value;
+  if (isSelfVar(p.b) && p.a.op === "lit") return p.a.value;
+  return void 0;
+}
+function cmpHolds(x, op, n) {
+  switch (op) {
+    case "gt":
+      return x > n;
+    case "ge":
+      return x >= n;
+    case "lt":
+      return x < n;
+    case "le":
+      return x <= n;
+  }
+}
+function boundHolds(lv, p) {
+  if (p.b.op !== "lit" || typeof p.b.value !== "number") return false;
+  const n = p.b.value;
+  if (isLengthSelf(p.a)) {
+    return typeof lv === "string" && cmpHolds(lv.length, p.op, n);
+  }
+  if (isSelfVar(p.a)) {
+    return typeof lv === "number" && cmpHolds(lv, p.op, n);
+  }
+  return false;
+}
+function isSelfVar(t) {
+  return t.op === "var" && t.id === SELF;
+}
+function isLengthSelf(t) {
+  return t.op === "app" && t.fn === "length" && t.args.length === 1 && isSelfVar(t.args[0]);
+}
+
+// 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/scan-top-functions.ts
+function listTopFunctions(source, file) {
+  const f = file ?? parseSource(source);
+  const names = [];
+  const localClasses = /* @__PURE__ */ new Map();
+  for (const stmt of f.program.body) {
+    if (stmt.type === "ClassDeclaration") {
+      const cname = stmt.id?.name;
+      if (cname) localClasses.set(cname, stmt);
+    }
+  }
+  const exportedClassNames = /* @__PURE__ */ new Set();
+  const collectClassMethods = (cname, decl) => {
+    const body = decl.body?.body ?? [];
+    for (const m of body) {
+      const mem = m;
+      const isMethod = mem.type === "MethodDefinition" || mem.type === "ClassMethod" || mem.type === "TSDeclareMethod";
+      if (!isMethod) continue;
+      if (mem.kind && mem.kind !== "method") continue;
+      const keyName = mem.key?.type === "Identifier" ? mem.key.name : void 0;
+      if (keyName) names.push(`${cname}.${keyName}`);
+    }
+  };
+  for (const stmt of f.program.body) {
+    let decl = stmt;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+      if (decl.type === "ArrowFunctionExpression" || decl.type === "FunctionExpression") {
+        if (!names.includes("default")) names.push("default");
+      }
+    }
+    if (decl.type === "FunctionDeclaration" && decl.id) names.push(decl.id.name);
+    if (decl.type === "FunctionDeclaration" && !decl.id && stmt.type === "ExportDefaultDeclaration") {
+      if (!names.includes("default")) names.push("default");
+    }
+    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);
+        }
+      }
+    }
+    if (decl.type === "ClassDeclaration" && decl.id?.name && (stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration")) {
+      const cname = decl.id.name;
+      exportedClassNames.add(cname);
+      collectClassMethods(cname, decl);
+    }
+  }
+  for (const stmt of f.program.body) {
+    if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) {
+      const specs = stmt.specifiers ?? [];
+      for (const spec of specs) {
+        const s = spec;
+        if (s.type !== "ExportSpecifier") continue;
+        const localName = s.local?.name;
+        if (!localName || exportedClassNames.has(localName)) continue;
+        const exportedName = s.exported?.name ?? s.exported?.value;
+        const isDefault = exportedName === "default";
+        if (!isDefault && exportedName !== localName) {
+        }
+        const decl = localClasses.get(localName);
+        if (!decl) continue;
+        exportedClassNames.add(localName);
+        collectClassMethods(localName, decl);
+      }
+    }
+    if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+      const d = stmt.declaration;
+      if (d.type === "Identifier") {
+        const localName = d.name;
+        if (!exportedClassNames.has(localName)) {
+          const decl = localClasses.get(localName);
+          if (decl) {
+            exportedClassNames.add(localName);
+            collectClassMethods(localName, decl);
+          }
+        }
+      }
+    }
+  }
+  for (const stmt of f.program.body) {
+    if (stmt.type !== "ExpressionStatement") continue;
+    const expr = stmt.expression;
+    if (!expr || expr.type !== "AssignmentExpression") continue;
+    const left = expr.left;
+    const right = expr.right;
+    if (!left || left.type !== "MemberExpression" || left.computed) continue;
+    const obj = left.object;
+    const prop = left.property;
+    const propName = prop?.type === "Identifier" ? prop.name : prop?.type === "StringLiteral" || prop?.type === "NumericLiteral" ? String(prop.value) : void 0;
+    const isExportsIdent = !!obj && obj.type === "Identifier" && obj.name === "exports";
+    const isModuleExportsMember = !!obj && obj.type === "MemberExpression" && obj.object?.name === "module" && obj.property?.name === "exports";
+    const isModuleExportsIdent = !!obj && obj.type === "Identifier" && obj.name === "module" && propName === "exports";
+    const pushFnFromInit = (fallbackName, init) => {
+      const r = init;
+      if (!r) return;
+      if (r.type !== "FunctionExpression" && r.type !== "ArrowFunctionExpression") return;
+      const n = r.id?.name ?? fallbackName;
+      if (n && !names.includes(n)) names.push(n);
+    };
+    if (isModuleExportsIdent) {
+      pushFnFromInit(void 0, right);
+      const objLit = right;
+      if (objLit?.type === "ObjectExpression") {
+        for (const p of objLit.properties ?? []) {
+          const prop2 = p;
+          if (prop2.type === "ObjectMethod" || prop2.type === "ClassMethod") {
+            const keyName2 = prop2.key?.type === "Identifier" ? prop2.key.name : prop2.key?.type === "StringLiteral" || prop2.key?.type === "NumericLiteral" ? String(prop2.key.value) : void 0;
+            if (keyName2 && !names.includes(keyName2)) names.push(keyName2);
+            continue;
+          }
+          if (prop2.type !== "ObjectProperty" && prop2.type !== "Property") continue;
+          const keyName = prop2.key?.type === "Identifier" ? prop2.key.name : prop2.key?.type === "StringLiteral" || prop2.key?.type === "NumericLiteral" ? String(prop2.key.value) : void 0;
+          if (keyName) pushFnFromInit(keyName, prop2.value);
+        }
+      }
+      continue;
+    }
+    if ((isExportsIdent || isModuleExportsMember) && propName) {
+      pushFnFromInit(propName, right);
+    }
+  }
+  return names;
+}
+
+// src/algebra/scan-injected-domain.ts
+function evidenceToString(v2) {
+  return typeof v2 === "string" ? JSON.stringify(v2) : String(v2);
+}
+function checkInjectedDomainEvidence(fnName, source, records, opts) {
+  const isLeaked = (r) => {
+    if (r.resultAbs && r.throwsAbs) {
+      return r.resultAbs.shape.k === "never" && r.throwsAbs.shape.k === "never";
+    }
+    return false;
+  };
+  const usable = records.filter((r) => !isLeaked(r));
+  if (usable.length === 0) return [];
+  let ei;
+  try {
+    ei = effectiveInterface(source, fnName, {
+      ...opts.loadModule ? { loadModule: opts.loadModule } : {},
+      fromFile: opts.fromFile,
+      ...opts.autoBind !== void 0 ? { autoBind: opts.autoBind } : {},
+      ...opts.projectDir !== void 0 ? { projectDir: opts.projectDir } : {}
+    });
+  } catch (e) {
+    return [
+      {
+        severity: "warning",
+        code: "nudo:interface-load",
+        message: `${fnName}: effective interface load failed (${e instanceof Error ? e.message : String(e)}); skipping domain-exceeds check`,
+        fn: fnName,
+        line: opts.loc?.line,
+        column: opts.loc?.column
+      }
+    ];
+  }
+  if (!ei || ei.source !== "handwritten") return [];
+  const out = [];
+  for (const { param, constraint } of ei.params) {
+    if (constraint.fields || constraint.element || constraint.fn) continue;
+    const idx = opts.paramNames.indexOf(param);
+    if (idx < 0) continue;
+    const failures = [];
+    for (const rec of usable) {
+      const lit2 = extractLiteralEvidence(rec, idx);
+      if (lit2 === void 0) continue;
+      if (!literalMeetsConstraint(lit2, constraint)) failures.push(lit2);
+    }
+    if (failures.length === 0) continue;
+    const shown = [...new Set(failures)].map(evidenceToString).join(", ");
+    out.push({
+      severity: "error",
+      code: "nudo:interface-domain-exceeds",
+      message: `${fnName}[${param}]: cross-file call-site domain evidence ${shown} exceeds handwritten contract`,
+      actual: shown,
+      expected: formatConstraint(constraint),
+      suggestion: `Loosen the handwritten contract for ${fnName} (${param}: ${formatConstraint(constraint)}), or fix the caller's values`,
+      fn: fnName,
+      line: opts.loc?.line,
+      column: opts.loc?.column
+    });
+  }
+  return out;
+}
+function extractLiteralEvidence(rec, idx) {
+  const absArg = rec.argAbs?.[idx];
+  if (!absArg) return void 0;
+  if (absArg.conf !== "exact" && absArg.conf !== "path") return void 0;
+  const lv = litValue(absArg);
+  if (typeof lv === "number" || typeof lv === "string" || typeof lv === "boolean") {
+    return lv;
+  }
+  return void 0;
+}
+
+// src/algebra/scan-call-graph.ts
+function requireSpecOf(init) {
+  if (init.type === "CallExpression") {
+    const callee = init.callee;
+    const args = init.arguments;
+    if (callee?.type === "Identifier" && callee.name === "require" && args?.[0]) {
+      return foldRequireSpecArg(args[0]);
+    }
+  }
+  if (init.type === "MemberExpression") {
+    const obj = init.object;
+    if (obj) return requireSpecOf(obj);
+  }
+  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) return void 0;
+  if (n.type === "ImportExpression") {
+    const src = n.source;
+    if (src?.type === "StringLiteral" && typeof src.value === "string") return String(src.value);
+    return void 0;
+  }
+  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, loadSpecFrom, depth = 0, baseFromFile = "", modFromFile = "") {
+  const here = () => ({
+    source: modSrc,
+    fromFile: modFromFile
+  });
+  if (depth > 3) return here();
+  try {
+    if (listTopFunctions(modSrc).includes(fnName)) return here();
+  } catch {
+    return here();
+  }
+  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 here();
+  const hopFrom = modFromFile || baseFromFile;
+  const next = hopFrom ? loadSpecFrom(nextSpec, hopFrom) : void 0;
+  if (!next) return here();
+  const nextFromFile = hopFrom ? resolveDepPath(hopFrom, nextSpec) : "";
+  return resolveExportSource(
+    next,
+    fnName,
+    loadSpecFrom,
+    depth + 1,
+    baseFromFile,
+    nextFromFile
+  );
+}
+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 obj = n;
+  if (typeof obj.type === "string") onStmt(obj);
+  if (!STMT_CONTAINER.has(String(obj.type))) return;
+  for (const key of Object.keys(obj)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "leadingComments") continue;
+    const val = obj[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 loadSpecFrom = (spec, from) => {
+    if (!load) return void 0;
+    const key = from + "\0" + spec;
+    if (!modCache.has(key)) modCache.set(key, load(spec, from));
+    return modCache.get(key);
+  };
+  const extFromFile = (spec) => fromFile ? resolveDepPath(fromFile, spec) : void 0;
+  const bindExternal = (local, modSrc, fnName, spec) => {
+    const r = resolveExportSource(modSrc, fnName, loadSpecFrom, 0, fromFile, extFromFile(spec) ?? "");
+    externalFn.set(local, {
+      source: r.source,
+      fnName,
+      ...r.fromFile ? { fromFile: r.fromFile } : {}
+    });
+  };
+  const loadSpec = (spec) => loadSpecFrom(spec, fromFile);
+  const visit2 = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj = n;
+    if (obj.type === "ImportDeclaration") {
+      const spec = obj.source;
+      if (spec?.type === "StringLiteral" && typeof spec.value === "string") {
+        const modSrc = loadSpec(String(spec.value));
+        if (modSrc) {
+          for (const sp of obj.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, String(spec.value));
+              }
+            } else if (sp.type === "ImportNamespaceSpecifier") {
+              const local = sp.local;
+              if (local?.name) {
+                const from = extFromFile(String(spec.value));
+                externalMember.set(
+                  `${local.name}.__module__`,
+                  { source: modSrc, fnName: "", ...from ? { fromFile: from } : {} }
+                );
+              }
+            } else if (sp.type === "ImportDefaultSpecifier") {
+              const local = sp.local;
+              if (local?.name) {
+                bindExternal(local.name, modSrc, "default", String(spec.value));
+              }
+            }
+          }
+        }
+      }
+    }
+    if (obj.type === "VariableDeclaration") {
+      for (const d of obj.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, dynSpec);
+            }
+          }
+          if (modSrc && id.type === "Identifier" && id.name) {
+            const from = extFromFile(dynSpec);
+            externalMember.set(
+              `${id.name}.__module__`,
+              { source: modSrc, fnName: "", ...from ? { fromFile: from } : {} }
+            );
+          }
+        }
+        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, spec);
+              }
+            }
+          }
+          if (id.type === "Identifier" && id.name && modSrc) {
+            const exportName = requireExportName(init);
+            if (exportName) {
+              bindExternal(id.name, modSrc, exportName, spec);
+            } else {
+              const from = extFromFile(spec);
+              externalMember.set(
+                `${id.name}.__module__`,
+                { source: modSrc, fnName: "", ...from ? { fromFile: from } : {} }
+              );
+            }
+          }
+        }
+        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, visit2);
+  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 obj = callee.object;
+    const prop = callee.property;
+    if (!callee.computed && obj?.type === "Identifier" && obj.name && prop?.type === "Identifier" && prop.name) {
+      const key = `${obj.name}.${prop.name}`;
+      const extM = resolve.externalMember.get(key);
+      if (extM) return { external: extM };
+      const mod = resolve.externalMember.get(`${obj.name}.__module__`);
+      if (mod?.source) {
+        return {
+          external: {
+            source: mod.source,
+            fnName: prop.name,
+            ...mod.fromFile ? { fromFile: mod.fromFile } : {}
+          }
+        };
+      }
+      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, (obj) => {
+    if (obj.type === "FunctionDeclaration") {
+      const id = obj.id;
+      tryFn(
+        id?.name ?? "",
+        obj.params ?? [],
+        obj.body
+      );
+    }
+    if (obj.type === "VariableDeclaration") {
+      for (const d of obj.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;
+}
+
+// src/algebra/scan.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;
+}
+function absUnknown() {
+  return { shape: { k: "unknown" }, conf: "partial" };
+}
+function isExactUndef(a) {
+  return a.term?.op === "lit" && (a.term.value === void 0 || a.term.value === null);
+}
+function isInformativeArg(a) {
+  if (!a || typeof a !== "object") return false;
+  if (a.term?.op === "lit") return true;
+  return a.shape?.k !== "unknown" && a.shape !== void 0;
+}
+function evalArgAbs(node, lookupVar) {
+  if (node.type === "Identifier" && typeof node.name === "string" && lookupVar) {
+    return lookupVar(node.name);
+  }
+  try {
+    const free = freeIdentifiers(node, []);
+    const bindings = {};
+    if (lookupVar) {
+      for (const name of free) {
+        const v2 = lookupVar(name);
+        if (v2) bindings[name] = v2;
+      }
+    }
+    return evalExprAbs(node, bindings);
+  } catch {
+    return void 0;
+  }
+}
+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 bCallIndex = /* @__PURE__ */ new Map();
+  for (const r of opts?.bCalls ?? []) {
+    if (!r.callLoc) continue;
+    const key = `${r.fnName}\0${r.callLoc.line}`;
+    const list = bCallIndex.get(key) ?? [];
+    list.push(r.args);
+    bCallIndex.set(key, list);
+  }
+  const takeBCallArgs = (fnName, line) => {
+    if (line === void 0) return void 0;
+    const list = bCallIndex.get(`${fnName}\0${line}`);
+    if (!list || list.length === 0) return void 0;
+    return list.shift();
+  };
+  const flattenPred = (p) => p.op === "and" ? p.args.flatMap(flattenPred) : p.op === "true" ? [] : [p];
+  const eiCache = /* @__PURE__ */ new Map();
+  const effectiveInterfaceOf = (fnName, fnSource, eiOpts) => {
+    const key = `${fnName}\0${eiOpts.fromFile ?? ""}\0${eiOpts.autoBind === false ? "0" : "1"}\0${eiOpts.projectDir ?? "-"}\0${hashSource(fnSource)}`;
+    if (eiCache.has(key)) return eiCache.get(key);
+    const r = effectiveInterface(fnSource, fnName, eiOpts);
+    eiCache.set(key, r);
+    return r;
+  };
+  const projectArgField = (arg, field) => {
+    if (!arg) return void 0;
+    if (arg.shape.k === "brand") {
+      return projectArgField(arg.shape.shape, field);
+    }
+    if (arg.shape.k !== "obj") return void 0;
+    return getSlot(arg.shape.slots, field)?.value;
+  };
+  const interfaceToIndexed = (ei, paramNames, formals) => {
+    const conflict = new Set(ei.conflict?.params ?? []);
+    const entries = [];
+    for (const { param, constraint } of ei.params) {
+      if (!param || conflict.has(param)) continue;
+      const idx = paramNames.indexOf(param);
+      if (idx >= 0) {
+        entries.push([
+          idx,
+          { param, pred: instantiateConstraint(constraint, param), constraint },
+          void 0
+        ]);
+        continue;
+      }
+      if (formals && formals.length > 0) {
+        const hit = locateContractParam(formals, param);
+        if (hit) {
+          entries.push([
+            hit.index,
+            { param, pred: instantiateConstraint(constraint, param), constraint },
+            hit.field
+          ]);
+        }
+      }
+    }
+    return entries;
+  };
+  const predEqLiteral = (p) => {
+    if (p.op !== "eq") return void 0;
+    const v2 = p.a.op === "var" && p.b.op === "lit" ? p.b.value : p.b.op === "var" && p.a.op === "lit" ? p.a.value : void 0;
+    return typeof v2 === "number" || typeof v2 === "string" || typeof v2 === "boolean" ? v2 : void 0;
+  };
+  const judgeLiteralPred = (p, lv, strLen) => {
+    if (p.op === "eq") {
+      const v2 = predEqLiteral(p);
+      return v2 === void 0 ? void 0 : lv === v2;
+    }
+    if (p.op !== "gt" && p.op !== "ge" && p.op !== "lt" && p.op !== "le") {
+      return void 0;
+    }
+    if (p.b.op !== "lit" || typeof p.b.value !== "number") return void 0;
+    const n = p.b.value;
+    if (p.a.op === "app" && p.a.fn === "length") {
+      if (strLen === void 0) return void 0;
+      if (p.op === "gt") return strLen > n;
+      if (p.op === "ge") return strLen >= n;
+      if (p.op === "lt") return strLen < n;
+      return strLen <= n;
+    }
+    if (typeof lv !== "number") return void 0;
+    if (p.op === "gt") return lv > n;
+    if (p.op === "ge") return lv >= n;
+    if (p.op === "lt") return lv < n;
+    return lv <= n;
+  };
+  const checkReqs = (displayName, reqs, paramNames, absArgs, argIndexOf, loc) => {
+    for (const [idx, pred, field, contractParam] of reqs) {
+      const argIdx = argIndexOf(idx);
+      if (argIdx === void 0) continue;
+      let arg = absArgs[argIdx];
+      if (!arg) continue;
+      const paramName = contractParam || paramNames[idx] || `arg${idx}`;
+      if (field) {
+        const projected = projectArgField(arg, field);
+        if (!projected) {
+          const k = arg.shape.k;
+          if (k !== "unknown" && k !== "any") {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+              actual: formatAbs(arg),
+              expected: `missing field ${field}`,
+              suggestion: `add the missing field ${field}`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+          continue;
+        }
+        arg = projected;
+      }
+      const lv = litValue(arg);
+      const isStr = arg.shape.k === "prim" && arg.shape.type === "string";
+      const strLen = typeof lv === "string" ? lv.length : void 0;
+      const argIsUndef = isExactUndef(arg);
+      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" : argIsUndef ? "undefined" : void 0;
+          if (actualPrim !== void 0 && actualPrim !== expected) {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+              actual: formatAbs(arg),
+              expected: `typeof ${paramName} = "${expected}"`,
+              suggestion: `use a value of type ${expected}, or relax the refine on ${paramName}`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+          continue;
+        }
+        if (argIsUndef) {
+          if (p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le" || p.op === "eq" || p.op === "or") {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+              actual: formatAbs(arg),
+              expected: predToString(p),
+              suggestion: `use a value satisfying ${predToString(p)}, or relax the precondition on ${paramName}`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+          continue;
+        }
+        if (lv === void 0) continue;
+        if (typeof lv === "number" || typeof lv === "string" || typeof lv === "boolean") {
+          if (p.op === "eq") {
+            const v2 = predEqLiteral(p);
+            if (v2 !== void 0 && lv !== v2) {
+              out.push({
+                severity: "error",
+                code: "nudo:constraint-violated",
+                message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+                actual: formatAbs(arg),
+                expected: predToString(p),
+                suggestion: `use a value satisfying ${predToString(p)}, or relax the precondition on ${paramName}`,
+                fn: displayName,
+                line: loc?.start.line,
+                column: loc?.start.column
+              });
+            }
+            continue;
+          }
+          if (p.op === "or") {
+            let pass = false;
+            let unknown3 = false;
+            for (const q of p.args) {
+              const r = judgeLiteralPred(q, lv, strLen);
+              if (r === true) {
+                pass = true;
+                break;
+              }
+              if (r === void 0) unknown3 = true;
+            }
+            if (!pass && !unknown3) {
+              out.push({
+                severity: "error",
+                code: "nudo:constraint-violated",
+                message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+                actual: formatAbs(arg),
+                expected: predToString(p),
+                suggestion: `use a value satisfying ${predToString(p)}, or relax the precondition on ${paramName}`,
+                fn: displayName,
+                line: loc?.start.line,
+                column: loc?.start.column
+              });
+            }
+            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) {
+              out.push({
+                severity: "error",
+                code: "nudo:constraint-violated",
+                message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+                actual: formatAbs(arg),
+                expected: `length(${paramName}) ${opSym} ${n}`,
+                suggestion: `use a value whose length is ${opSym} ${n}, or relax the precondition on ${paramName}`,
+                fn: displayName,
+                line: loc?.start.line,
+                column: loc?.start.column
+              });
+            }
+            continue;
+          }
+          if (typeof lv === "boolean" || lv === null) {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+              actual: formatAbs(arg),
+              expected: predToString(p),
+              suggestion: `use a value satisfying ${predToString(p)}, or relax the precondition on ${paramName}`,
+              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) {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+              actual: formatAbs(arg),
+              expected: predToString(p),
+              suggestion: `use a value satisfying ${predToString(p)}, or relax the precondition on ${paramName}`,
+              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}]: argument \u22AD precondition`,
+          actual: formatAbs(absArg),
+          expected: `object shape at ${path}`,
+          suggestion: `use an object satisfying the ${path} shape constraint`,
+          fn: displayName,
+          line: loc?.start.line,
+          column: loc?.start.column
+        });
+      }
+      return;
+    }
+    for (const [key, field] of Object.entries(constraint.fields)) {
+      const slot = getSlot(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}]: argument \u22AD precondition`,
+            actual: formatAbs(absArg),
+            expected: `missing field ${fieldPath}`,
+            suggestion: `add the missing field ${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}]: argument \u22AD precondition`,
+          actual: formatAbs(fieldAbs),
+          expected: `typeof ${fieldPath} = "${constraint.prim}"`,
+          suggestion: `change ${fieldPath} to ${constraint.prim}`,
+          fn: displayName,
+          line: loc?.start.line,
+          column: loc?.start.column
+        });
+        return;
+      }
+    }
+    if (isIntFlag(constraint)) {
+      const iv = litValue(fieldAbs);
+      if (typeof iv === "number" && !Number.isInteger(iv)) {
+        out.push({
+          severity: "error",
+          code: "nudo:constraint-violated",
+          message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+          actual: formatAbs(fieldAbs),
+          expected: `${fieldPath} is int`,
+          suggestion: `change ${fieldPath} to an integer`,
+          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}]: argument \u22AD precondition`,
+                actual: formatAbs(fieldAbs),
+                expected: `length(${fieldPath}) ${opSym} ${n}`,
+                suggestion: `use a ${fieldPath} whose length is ${opSym} ${n}`,
+                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}]: argument \u22AD precondition`,
+              actual: formatAbs(fieldAbs),
+              expected: `${fieldPath} ${opSym} ${n}`,
+              suggestion: `use a value satisfying ${fieldPath} ${opSym} ${n}, or relax the precondition on ${paramName}`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+        }
+      }
+    }
+    if (lv !== void 0 && (typeof lv === "number" || typeof lv === "string" || typeof lv === "boolean") && ((constraint.members?.length ?? 0) > 0 || constraint.preds.some((p) => p.op === "eq")) && !literalMeetsConstraint(lv, constraint)) {
+      out.push({
+        severity: "error",
+        code: "nudo:constraint-violated",
+        message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+        actual: formatAbs(fieldAbs),
+        expected: `${fieldPath} \u2208 ${formatConstraint(constraint)}`,
+        suggestion: `use a ${fieldPath} satisfying ${formatConstraint(constraint)}`,
+        fn: displayName,
+        line: loc?.start.line,
+        column: loc?.start.column
+      });
+    }
+  };
+  const checkShapeReqs = (displayName, reqs, paramNames, absArgs, argIndexOf, loc) => {
+    for (const [idx, entry, field] of reqs) {
+      const c = entry.constraint;
+      if (!c.fields && !c.element && !isIntFlag(c) && !c.prim) continue;
+      const argIdx = argIndexOf(idx);
+      if (argIdx === void 0) continue;
+      let arg = absArgs[argIdx];
+      if (!arg) continue;
+      const paramName = entry.param || paramNames[idx] || `arg${idx}`;
+      if (field) {
+        const projected = projectArgField(arg, field);
+        if (!projected) {
+          const k = arg.shape.k;
+          if (k !== "unknown" && k !== "any") {
+            out.push({
+              severity: "error",
+              code: "nudo:constraint-violated",
+              message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+              actual: formatAbs(arg),
+              expected: `missing field ${field}`,
+              suggestion: `add the missing field ${field}`,
+              fn: displayName,
+              line: loc?.start.line,
+              column: loc?.start.column
+            });
+          }
+          continue;
+        }
+        arg = projected;
+      }
+      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 (isExactUndef(arg) || arg.shape.k !== "unknown" && arg.shape.k !== "any") {
+          out.push({
+            severity: "error",
+            code: "nudo:constraint-violated",
+            message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+            actual: formatAbs(arg),
+            expected: `array at ${paramName}`,
+            suggestion: `use a value satisfying the array constraint`,
+            fn: displayName,
+            line: loc?.start.line,
+            column: loc?.start.column
+          });
+        }
+      }
+      if (isIntFlag(c)) {
+        const iv = litValue(arg);
+        if (typeof iv === "number" && !Number.isInteger(iv)) {
+          out.push({
+            severity: "error",
+            code: "nudo:constraint-violated",
+            message: `${displayName}[${paramName}]: argument \u22AD precondition`,
+            actual: formatAbs(arg),
+            expected: `${paramName} is int`,
+            suggestion: `use an integer`,
+            fn: displayName,
+            line: loc?.start.line,
+            column: loc?.start.column
+          });
+        }
+      }
+    }
+  };
+  const parseCallArgs = (args) => {
+    const absArgs = [];
+    let hasInfo = false;
+    const note = (abs2) => {
+      if (abs2 && isInformativeArg(abs2)) hasInfo = true;
+    };
+    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 num = a.argument;
+        absArgs.push(numLit(-num.value));
+        hasInfo = true;
+      } else if (a.type === "ObjectExpression") {
+        const abs2 = evalArgAbs(a, (n) => varAbs.get(n));
+        absArgs.push(abs2 ?? absUnknown());
+        note(abs2);
+      } else if (a.type === "ArrayExpression") {
+        const abs2 = evalArgAbs(a, (n) => varAbs.get(n));
+        absArgs.push(abs2 ?? absUnknown());
+        note(abs2);
+      } 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());
+        note(abs2);
+      } else if (a.type === "MemberExpression") {
+        const computed = a.computed === true;
+        const prop = a.property;
+        const litKey = prop?.type === "StringLiteral" || prop?.type === "NumericLiteral";
+        if (computed && !litKey) {
+          absArgs.push(anyAbs);
+          hasInfo = true;
+          continue;
+        }
+        const abs2 = evalArgAbs(a, (n) => varAbs.get(n));
+        absArgs.push(abs2 ?? absUnknown());
+        note(abs2);
+      } else if (a.type === "SpreadElement") {
+        const inner = a.argument;
+        if (inner?.type === "ArrayExpression") {
+          for (const el of inner.elements ?? []) {
+            if (!el) continue;
+            if (el.type === "NumericLiteral" && typeof el.value === "number") {
+              absArgs.push(numLit(el.value));
+              hasInfo = true;
+            } else if (el.type === "StringLiteral" && typeof el.value === "string") {
+              absArgs.push({
+                shape: { k: "prim", type: "string" },
+                term: { op: "lit", value: el.value },
+                conf: "exact"
+              });
+              hasInfo = true;
+            } else {
+              const abs2 = evalArgAbs(el, (n) => varAbs.get(n));
+              absArgs.push(abs2 ?? absUnknown());
+              note(abs2);
+            }
+          }
+        } else {
+          absArgs.push(absUnknown());
+        }
+      } else if (a.type === "CallExpression") {
+        absArgs.push(absUnknown());
+      } else {
+        absArgs.push(absUnknown());
+      }
+    }
+    return { absArgs, hasInfo };
+  };
+  const checkOneCall = (fnName, args, loc) => {
+    if (!knownFns.includes(fnName)) return;
+    checkArgStructures(fnName, source, args, loc);
+    const parsed = parseCallArgs(args);
+    let absArgs = parsed.absArgs;
+    let hasInfo = parsed.hasInfo;
+    if (!hasInfo) {
+      const bArgs = takeBCallArgs(fnName, loc?.start.line);
+      if (bArgs && bArgs.length > 0) {
+        absArgs = bArgs;
+        hasInfo = bArgs.some(isInformativeArg);
+      }
+    }
+    if (!hasInfo || absArgs.length === 0) return;
+    const g = generalizeFromAst(fnName, source, {
+      file,
+      refine: {
+        loadModule: opts?.loadModule,
+        fromFile: opts?.fromFile ?? "",
+        ...opts?.autoBind !== void 0 ? { autoBind: opts.autoBind } : {},
+        ...opts?.projectDir !== void 0 ? { projectDir: opts.projectDir } : {}
+      }
+    });
+    const paramNames = g?.params ?? [];
+    const optsR = {
+      loadModule: opts?.loadModule,
+      fromFile: opts?.fromFile ?? "",
+      ...opts?.autoBind !== void 0 ? { autoBind: opts.autoBind } : {},
+      ...opts?.projectDir !== void 0 ? { projectDir: opts.projectDir } : {}
+    };
+    const ownEi = effectiveInterfaceOf(fnName, source, optsR);
+    if (ownEi?.source === "handwritten") {
+      const ownFull = interfaceToIndexed(ownEi, paramNames, g?.formals);
+      checkShapeReqs(fnName, ownFull, paramNames, absArgs, (i) => i, loc);
+      checkReqs(
+        fnName,
+        ownFull.map(([i, e, f]) => [i, e.pred, f, e.param]),
+        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 tEi = effectiveInterfaceOf(fwd.target, source, optsR);
+      const tFull = tEi?.source === "handwritten" ? interfaceToIndexed(tEi, tParams, tg?.formals) : [];
+      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, f]) => [i, e.pred, f, e.param]),
+          tParams,
+          absArgs,
+          mapArg,
+          loc
+        );
+      }
+    }
+  };
+  const checkExternalCall = (ext, args, displayName, loc) => {
+    checkArgStructures(ext.fnName, ext.source, args, loc, displayName, ext.fromFile);
+    const parsedExt = parseCallArgs(args);
+    let absArgs = parsedExt.absArgs;
+    let hasInfo = parsedExt.hasInfo;
+    if (!hasInfo) {
+      const bArgs = takeBCallArgs(ext.fnName, loc?.start.line);
+      if (bArgs && bArgs.length > 0) {
+        absArgs = bArgs;
+        hasInfo = bArgs.some(isInformativeArg);
+      }
+    }
+    if (!hasInfo || absArgs.length === 0) return;
+    let full = [];
+    let paramNames = [];
+    try {
+      const g = generalizeFromAst(ext.fnName, ext.source);
+      paramNames = g?.params ?? [];
+      const eiOpts = {
+        loadModule: opts?.loadModule,
+        fromFile: ext.fromFile ?? opts?.fromFile ?? "",
+        ...ext.fromFile ? {} : { autoBind: false },
+        ...ext.fromFile && opts?.autoBind !== void 0 ? { autoBind: opts.autoBind } : {},
+        ...opts?.projectDir !== void 0 ? { projectDir: opts.projectDir } : {}
+      };
+      const ei = effectiveInterfaceOf(ext.fnName, ext.source, eiOpts);
+      if (ei?.source === "handwritten") {
+        full = interfaceToIndexed(ei, paramNames, g?.formals);
+      }
+    } catch {
+      out.push({
+        severity: "warning",
+        code: "nudo:no-signature",
+        message: `${displayName}: external callee contract could not be resolved; skipping call-site precondition check`,
+        fn: displayName,
+        line: loc?.start.line,
+        column: loc?.start.column
+      });
+      return;
+    }
+    checkShapeReqs(displayName, full, paramNames, absArgs, (i) => i, loc);
+    checkReqs(
+      displayName,
+      full.map(([i, e, f]) => [i, e.pred, f, e.param]),
+      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}]: argument is not a callable fn`,
+          actual: formatAbs(absArg),
+          expected: formatShape(expected),
+          suggestion: `expected ${formatShape(expected)}`,
+          fn: displayName,
+          line: loc?.start.line,
+          column: loc?.start.column
+        });
+      }
+    }
+  };
+  const checkArgStructures = (fnName, fnSource, args, loc, displayName, _interfaceFromFile) => {
+    let gFn;
+    try {
+      const sameFile = fnSource === source;
+      gFn = generalizeFromAst(
+        fnName,
+        fnSource,
+        {
+          ...sameFile && file ? { file } : {},
+          // refine 侧车/源码契约必须进 generalize——否则 fnRels 只剩 promote，
+          // refine→error 路径永远打不开（source 永远是 warning）。
+          refine: {
+            loadModule: opts?.loadModule,
+            fromFile: opts?.fromFile ?? "",
+            ...opts?.autoBind !== void 0 ? { autoBind: opts.autoBind } : {},
+            ...opts?.projectDir !== void 0 ? { projectDir: opts.projectDir } : {}
+          }
+        }
+      );
+    } catch (e) {
+      out.push({
+        severity: "warning",
+        code: "nudo:no-signature",
+        message: `${displayName ?? fnName}: signature recovery failed (${e instanceof Error ? e.message : String(e)}); skipping call-site checks`,
+        fn: displayName ?? fnName,
+        line: loc?.start.line,
+        column: loc?.start.column
+      });
+      return;
+    }
+    if (gFn?.fnRels && gFn.fnRels.size > 0) {
+      checkHofFnRelArgs(
+        gFn,
+        args,
+        loc,
+        displayName ?? fnName,
+        (n) => evalArgAbs(n, (x) => varAbs.get(x))
+      );
+    }
+  };
+  const visit2 = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj = n;
+    if (obj.type === "CallExpression") {
+      const callee = obj.callee;
+      const args = obj.arguments ?? [];
+      const resolved = resolveCalleeFn(callee, resolve, knownSet);
+      if (typeof resolved === "string") {
+        checkOneCall(resolved, args, obj.loc);
+      } else if (resolved?.external) {
+        const name = resolved.external.fnName || "require()";
+        checkExternalCall(resolved.external, args, name, obj.loc);
+      }
+    }
+    for (const key of Object.keys(obj)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const val = obj[key];
+      if (Array.isArray(val)) val.forEach(visit2);
+      else if (val && typeof val === "object") visit2(val);
+    }
+  };
+  visit2(file);
+  return out;
+}
+
+export {
+  SELF,
+  getTerm,
+  lenTerm,
+  isNudoConstraint,
+  isIntFlag,
+  number,
+  string,
+  boolean,
+  any,
+  array,
+  shape,
+  litC,
+  union,
+  fn,
+  andC,
+  partial,
+  pick,
+  omit,
+  instantiateConstraint,
+  constraintToEntryAbs,
+  fnConstraintToEntryReqs,
+  throwConstraintToKinds,
+  hashSource,
+  resetHashSourceCache,
+  normPath,
+  resolveDepPath,
+  isNodeModulesPath,
+  sidecarPathOf,
+  extractNudoImports,
+  setRefineDiagCollector,
+  refineDiagCount,
+  takeRefineDiags,
+  takeRefineDiagsSince,
+  NudoSidecarError,
+  execNudoModule,
+  resetNudoModuleExecCache,
+  extractRefinesFromSource,
+  refineToIndexedFull,
+  extractRefineReturnFromSource,
+  extractDeclaredThrows,
+  setInterfaceDiagCollector,
+  interfaceDiagCount,
+  takeInterfaceDiags,
+  takeInterfaceDiagsSince,
+  localNamedExports,
+  generatedExportNames,
+  effectiveInterface,
+  sidecarClosureFingerprint,
+  formatConstraint,
+  formatEffectiveInterfaceDisplay,
+  formatInterfaceTierLine,
+  interfaceTierOf,
+  interfaceSourceOf,
+  resetFnFpCache,
+  getFnNameAndBodies,
+  fnFingerprints,
+  generalizeSourceKeyPart,
+  canSkipLiteralCallScan,
+  extractAllLoadSpecs,
+  sidecarSpecsOf,
+  loadModuleDepsFingerprint,
+  collectAbsFreeVars,
+  resetGeneralizeMemo,
+  getGeneralizeMemoSize,
+  evictGeneralizeMemoForPaths,
+  extractFn,
+  generalizeFromAst,
+  generalizeAll,
+  listFunctionNames,
+  buildArgsFromAssume,
+  literalMeetsConstraint,
+  stableAnalyzeKeySource,
+  listTopFunctions,
+  checkInjectedDomainEvidence,
+  scanLiteralCalls
+};