@nudojs/core 1.7.9 → 1.8.0

package/dist/{chunk-5SAMWKI6.js → chunk-WT5J6QTZ.js}

@@ -1,16 +1,18 @@
 import {
   $invoke,
   $new,
+  CONSTRAINT_BUILDERS,
   abs,
-  and,
+  andC,
   anyAbs,
-  app,
   callTranspiledExportFull,
+  constraintToEntryAbs,
   createScopedSlot,
   defaultLeakBudget,
+  derefConstraint,
   emptyEnv,
-  eq,
   evalExprAbs,
+  fnConstraintToEntryReqs,
   foldRequireSpecArg,
   formalParamDisplayNames,
   formalParamsFromNodes,
@@ -18,37 +20,32 @@ import {
   formatShape,
   formatShapeSlot,
   freeIdentifiers,
-  ge,
   getFnImpl,
   getSlot,
-  gt,
   identBoundaryRegex,
-  joinAbs,
-  le,
-  lit,
+  instantiateConstraint,
+  isIntFlag,
+  isNudoConstraint,
   litKeyString,
   litValue,
+  literalMeetsConstraint,
   locateContractParam,
-  lt,
   numLit,
-  or,
   pTrue,
   parseSource,
   predToString,
-  primToTypeof,
-  ptypeof,
   registerCollectorScopeParticipant,
   runTranspiledOptionsMemoKey,
   snapshotAbs,
   stripStringsKeepComments,
   termToString,
+  throwConstraintToKinds,
   tryRunTranspiled,
-  unknown,
   v,
   withEvalBudgetOverride,
   withExecPhi,
   withFnBudgetOverride
-} from "./chunk-YQIRU637.js";
+} from "./chunk-P6O5BXOA.js";
 
 // src/algebra/directive-scan.ts
 function cleanDirectiveLine(raw, kind) {
@@ -153,16 +150,16 @@ function listFnDirectiveScopes(file) {
           const decl = d;
           const idName = decl.id?.type === "Identifier" ? decl.id.name : void 0;
           if (isFnExpr(decl.init)) {
-            const fn2 = decl.init;
+            const fn = decl.init;
             const scope = buildScope(
               idName ?? "<anonymous>",
-              fn2,
+              fn,
               ctx.wrapperNode,
               node.leadingComments,
               ctx.wrapperNode?.leadingComments
             );
             out.push(scope);
-            visit2(fn2, { owner: idName });
+            visit2(fn, { owner: idName });
           } else {
             visit2(decl.init, { owner: idName, commentHost: node, wrapperNode: ctx.wrapperNode });
           }
@@ -360,17 +357,17 @@ function listFnDirectiveScopes(file) {
         const vd = raw;
         const idName = vd.id?.type === "Identifier" ? vd.id.name : void 0;
         if (isFnExpr(vd.init)) {
-          const fn2 = vd.init;
+          const fn = vd.init;
           out.push(
             buildScope(
               idName ?? "default",
-              fn2,
+              fn,
               wrapper,
               d.leadingComments,
               wrapper.leadingComments
             )
           );
-          visit2(fn2, { owner: idName });
+          visit2(fn, { owner: idName });
         } else {
           visit2(vd.init, {
             owner: idName,
@@ -419,10 +416,10 @@ function parseEnvPayload(payload) {
   return payload.split(",").map((e) => e.trim().replace(/^['"]|['"]$/g, "")).filter((e) => e && (/^\w+$/.test(e) || isPathLikeEnv(e)));
 }
 function parseMockModulePayload(payload) {
-  const partial2 = payload.match(/^\s*"([^"]+)"\s*\{([^}]+)\}\s*from\s*"([^"]+)"\s*$/);
-  if (partial2) {
-    const names = partial2[2].split(",").map((n) => n.trim()).filter(Boolean);
-    return { source: partial2[1], names, fromPath: partial2[3] };
+  const partial = payload.match(/^\s*"([^"]+)"\s*\{([^}]+)\}\s*from\s*"([^"]+)"\s*$/);
+  if (partial) {
+    const names = partial[2].split(",").map((n) => n.trim()).filter(Boolean);
+    return { source: partial[1], names, fromPath: partial[3] };
   }
   const full = payload.match(/^\s*"([^"]+)"\s+from\s*"([^"]+)"\s*$/);
   if (full) {
@@ -617,15 +614,15 @@ function scanContractSegments(lines) {
 }
 function scanThrowsDecl(lines) {
   const kinds = /* @__PURE__ */ new Set();
-  let any2 = false;
+  let any = false;
   for (const line of lines) {
     const th = line.match(/^@nudo:throws\s+(.+)$/i);
     if (th) {
       const spec = th[1].trim();
-      if (spec === "*") any2 = true;
+      if (spec === "*") any = true;
       else {
         for (const k of spec.split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean)) {
-          if (k === "*") any2 = true;
+          if (k === "*") any = true;
           else kinds.add(k);
         }
       }
@@ -633,16 +630,16 @@ function scanThrowsDecl(lines) {
     const cs = line.match(/!!\s*throws(?:\s+([A-Za-z*][\w*|,\s]*))?/i);
     if (cs) {
       const spec = (cs[1] ?? "*").trim();
-      if (spec === "" || spec === "*") any2 = true;
+      if (spec === "" || spec === "*") any = true;
       else {
         for (const k of spec.split(/[,\s|]+/).map((s) => s.trim()).filter(Boolean)) {
-          if (k === "*") any2 = true;
+          if (k === "*") any = true;
           else kinds.add(k);
         }
       }
     }
   }
-  if (any2) return "*";
+  if (any) return "*";
   if (kinds.size > 0) return [...kinds].join(",");
   return void 0;
 }
@@ -753,8 +750,8 @@ function createDiagChannel(cap) {
   let seq = 0;
   const buf = [];
   return {
-    setCollector(fn2) {
-      collector = fn2;
+    setCollector(fn) {
+      collector = fn;
     },
     getCollector() {
       return collector;
@@ -789,7 +786,7 @@ function createScopedDiagChannel(cap) {
   const fallback = createDiagChannel(cap);
   const chan = () => als.getStore() ?? fallback;
   return {
-    setCollector: (fn2) => chan().setCollector(fn2),
+    setCollector: (fn) => chan().setCollector(fn),
     getCollector: () => chan().getCollector(),
     count: () => chan().count(),
     take: () => chan().take(),
@@ -803,529 +800,6 @@ function createScopedDiagChannel(cap) {
   };
 }
 
-// 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 nullable(c) {
-  return makeBuilder(void 0, [], {
-    members: [
-      asNestedConstraint(c, "nullable()"),
-      toPlainConstraint(litC(null)),
-      toPlainConstraint(litC(void 0))
-    ]
-  });
-}
-function constraintAdmitsNullish(c) {
-  if (c.members) return c.members.some((m) => constraintAdmitsNullish(m));
-  if (!c.prim && c.preds.length === 0 && !c.fields && !c.element && !c.fn) return true;
-  for (const p of c.preds) {
-    for (const flat of p.op === "and" ? p.args : [p]) {
-      if (flat.op !== "eq") continue;
-      for (const side of [flat.a, flat.b]) {
-        if (side.op === "lit" && (side.value === null || side.value === void 0)) return true;
-      }
-    }
-  }
-  return false;
-}
-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 });
-}
-var CONSTRAINT_BUILDERS = {
-  number,
-  string,
-  boolean,
-  any,
-  array,
-  shape,
-  lit: litC,
-  union,
-  nullable,
-  fn,
-  and: andC,
-  partial,
-  pick,
-  omit
-};
-var CONSTRAINT_BUILDER_NAMES = Object.keys(
-  CONSTRAINT_BUILDERS
-);
-var CONSTRAINT_EXPR_RE = new RegExp(
-  `^(${CONSTRAINT_BUILDER_NAMES.join("|")})\\s*\\(`
-);
-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 { ok: false };
-  const p = leaves[0];
-  if (p.op !== "eq") return { ok: false };
-  if (p.a.op === "var" && p.b.op === "lit") {
-    return { ok: true, v: p.b.value };
-  }
-  if (p.b.op === "var" && p.a.op === "lit") {
-    return { ok: true, v: p.a.value };
-  }
-  return { ok: false };
-}
-function samePrimLiteralUnionAbs(members, t) {
-  if (members.length === 0) return void 0;
-  const values = [];
-  let prim;
-  for (const m of members) {
-    const mk = memberLitValue(m);
-    if (!mk.ok) return void 0;
-    const v2 = mk.v;
-    if (v2 === void 0 || 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 allEqNullish = c.preds.length > 0 && c.preds.every(
-    (p) => p.op === "eq" && (p.b.op === "lit" && (p.b.value === null || p.b.value === void 0) || p.a.op === "lit" && (p.a.value === null || p.a.value === void 0))
-  );
-  if (allEqNullish) {
-    let nullish = null;
-    for (const p of c.preds) {
-      if (p.op !== "eq") continue;
-      if (p.b.op === "lit" && (p.b.value === null || p.b.value === void 0)) {
-        nullish = p.b.value;
-        break;
-      }
-      if (p.a.op === "lit" && (p.a.value === null || p.a.value === void 0)) {
-        nullish = p.a.value;
-        break;
-      }
-    }
-    return abs({ k: "unknown" }, lit(nullish), void 0, "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/refine.ts
 function diagnoseMalformedNudoImports(source) {
   for (const bad of scanMalformedNudoImports(source)) {
@@ -1352,8 +826,8 @@ function extractNudoImports(source) {
 var MAX_REFINE_DIAGS = 1024;
 var refineDiagChannel = createScopedDiagChannel(MAX_REFINE_DIAGS);
 registerCollectorScopeParticipant((body) => refineDiagChannel.runScoped(body));
-function setRefineDiagCollector(fn2) {
-  refineDiagChannel.setCollector(fn2);
+function setRefineDiagCollector(fn) {
+  refineDiagChannel.setCollector(fn);
 }
 function refineDiagCount() {
   return refineDiagChannel.count();
@@ -1730,13 +1204,13 @@ function execSidecar(src, opts, chain, preloaded) {
   const body = `${prologue.length > 0 ? `${prologue.join("\n")}
 ` : ""}${code}
 return { ${returnObj} };`;
-  const fn2 = new Function(
+  const fn = new Function(
     ...Object.keys(sidecarInjects),
     "__nudoInjects",
     "__nudoDeps",
     body
   );
-  return fn2(...Object.values(sidecarInjects), sidecarInjects, deps);
+  return fn(...Object.values(sidecarInjects), sidecarInjects, deps);
 }
 function execNudoModule(src, opts) {
   return execNudoModuleCached(src, opts ?? {});
@@ -2250,8 +1724,8 @@ function regionHasGeneratedMarker(stmts, exportIdx, src) {
 var MAX_INTERFACE_DIAGS = 1024;
 var interfaceDiagChannel = createScopedDiagChannel(MAX_INTERFACE_DIAGS);
 registerCollectorScopeParticipant((body) => interfaceDiagChannel.runScoped(body));
-function setInterfaceDiagCollector(fn2) {
-  interfaceDiagChannel.setCollector(fn2);
+function setInterfaceDiagCollector(fn) {
+  interfaceDiagChannel.setCollector(fn);
 }
 function interfaceDiagCount() {
   return interfaceDiagChannel.count();
@@ -2512,11 +1986,11 @@ function crossBoundConflict(a, b) {
       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 eq of eqA) {
+    if (typeof eq.value === "number" && boundExcludes(B, eq.term, eq.value)) return true;
   }
-  for (const eq2 of eqB) {
-    if (typeof eq2.value === "number" && boundExcludes(A, eq2.term, eq2.value)) return true;
+  for (const eq of eqB) {
+    if (typeof eq.value === "number" && boundExcludes(A, eq.term, eq.value)) return true;
   }
   return false;
 }
@@ -2712,9 +2186,9 @@ function predToChain(p) {
           [a, b],
           [b, a]
         ]) {
-          const ge2 = lengthBound(x, "ge");
-          const le2 = lengthBound(y, "le");
-          if (ge2 !== void 0 && ge2 === le2) return `.length(${ge2})`;
+          const ge = lengthBound(x, "ge");
+          const le = lengthBound(y, "le");
+          if (ge !== void 0 && ge === le) return `.length(${ge})`;
         }
       }
       return p.args.map(predToChain).join("");
@@ -2724,24 +2198,29 @@ function predToChain(p) {
   }
   return `{${predToString(p)}}`;
 }
-function fmtConstraint(c) {
+var LAZY_DISPLAY_DEPTH = 2;
+function fmtConstraint(c, depth = LAZY_DISPLAY_DEPTH) {
+  if (c.lazy) {
+    if (depth <= 0) return "\u2026";
+    return fmtConstraint(derefConstraint(c), depth - 1);
+  }
   if (c.fn) {
     const args = [
-      `{ ${Object.entries(c.fn.params).map(([k, v2]) => `${k}: ${fmtConstraint(v2)}`).join(", ")} }`
+      `{ ${Object.entries(c.fn.params).map(([k, v2]) => `${k}: ${fmtConstraint(v2, depth)}`).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)} }`);
+    if (c.fn.returns !== void 0) args.push(fmtConstraint(c.fn.returns, depth));
+    if (c.fn.throws !== void 0) args.push(`{ throws: ${fmtConstraint(c.fn.throws, depth)} }`);
     return `fn(${args.join(", ")})`;
   }
-  if (c.members) return `union(${c.members.map(fmtConstraint).join(", ")})`;
+  if (c.members) return `union(${c.members.map((m) => fmtConstraint(m, depth)).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 `${k}${opt}: ${fmtConstraint(f.constraint, depth)}`;
     });
     return `shape({ ${fs.join(", ")} })`;
   }
-  if (c.element) return `array(${fmtConstraint(c.element)})`;
+  if (c.element) return `array(${fmtConstraint(c.element, depth)})`;
   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)})`;
   }
@@ -3361,8 +2840,8 @@ function alphaOfTerm(t, ctx) {
 }
 function rawTermOf(arg, ctx) {
   if (arg?.type === "Identifier") {
-    const lt2 = ctx.localTerms.get(arg.name);
-    if (lt2) return lt2;
+    const lt = ctx.localTerms.get(arg.name);
+    if (lt) return lt;
     if (ctx.paramTermId.has(arg.name)) {
       return v(ctx.paramTermId.get(arg.name));
     }
@@ -3374,22 +2853,22 @@ function rawTermOf(arg, ctx) {
 }
 function alphaTermOf(arg, ctx) {
   if (arg?.type === "Identifier") {
-    const lt2 = ctx.localTerms.get(arg.name);
-    if (lt2) return lt2;
+    const lt = ctx.localTerms.get(arg.name);
+    if (lt) return lt;
     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) {
+function promoteShape(ctx, param, shape, 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" };
+  const next = { shape, term: prev.term, pred: prev.pred, conf: "path" };
   ctx.shapes.set(param, next);
-  ctx.promotedShapes.set(param, shape2);
-  if (shape2.k === "fn") {
+  ctx.promotedShapes.set(param, shape);
+  if (shape.k === "fn") {
     if (!ctx.fnRels.has(param) && !ctx.entryShapes.has(param)) {
       ctx.fnRels.set(param, { abs: { ...next }, source: "promote" });
     }
@@ -3397,7 +2876,7 @@ function promoteShape(ctx, param, shape2, loc, recordSite = true) {
       ctx.sites.push({
         param,
         argTerms: [],
-        result: shape2.returnType ?? next,
+        result: shape.returnType ?? next,
         loc
       });
     }
@@ -3684,12 +3163,12 @@ function evictGeneralizeMemoForPaths(paths) {
   }
   return n;
 }
-function loadModuleId(fn2) {
-  if (!fn2) return 0;
-  let id = loadModuleIds.get(fn2);
+function loadModuleId(fn) {
+  if (!fn) return 0;
+  let id = loadModuleIds.get(fn);
   if (id === void 0) {
     id = nextLoadModuleId++;
-    loadModuleIds.set(fn2, id);
+    loadModuleIds.set(fn, id);
   }
   return id;
 }
@@ -3934,9 +3413,9 @@ function extractFn(source, fnName, fileAst) {
     });
     formalsByName.set(scope.name, formals);
   }
-  const fn2 = env.fns.get(fnName);
-  if (!fn2) return void 0;
-  return { params: fn2.params, body: fn2.body, env, formals: formalsByName.get(fnName) ?? [] };
+  const fn = env.fns.get(fnName);
+  if (!fn) return void 0;
+  return { params: fn.params, body: fn.body, env, formals: formalsByName.get(fnName) ?? [] };
 }
 function generalizeFromAst(fnName, source, opts = {}) {
   const { key, depPaths, truncated } = generalizeMemoKey(fnName, source, opts);
@@ -4099,9 +3578,9 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
         return void 0;
       } else if (fnName in evalRun) {
         const evalArgs = 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" };
+          const shape = promoteScan.promotedShapes.get(params[i]);
+          if (shape && (a.shape.k === "any" || a.shape.k === "unknown")) {
+            return { shape, term: a.term, pred: a.pred, conf: "path" };
           }
           return a;
         });
@@ -4288,92 +3767,6 @@ function buildArgsFromAssume(source, fnName, assumeIds) {
   });
 }
 
-// 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;
-    case "undefined":
-      return lv === void 0;
-    default:
-      return false;
-  }
-}
-function predHolds(lv, p) {
-  switch (p.op) {
-    case "eq": {
-      const litT = isSelfVar(p.a) && p.b.op === "lit" ? p.b : isSelfVar(p.b) && p.a.op === "lit" ? p.a : void 0;
-      if (!litT) return false;
-      return Object.is(lv, litT.value);
-    }
-    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 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;
@@ -4608,9 +4001,9 @@ function checkInjectedDomainEvidence(fnName, source, records, opts) {
     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);
+      const lit = extractLiteralEvidence(rec, idx);
+      if (lit === void 0) continue;
+      if (!literalMeetsConstraint(lit, constraint)) failures.push(lit);
     }
     if (failures.length === 0) continue;
     const shown = [...new Set(failures)].map(evidenceToString).join(", ");
@@ -5213,16 +4606,16 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
           }
           if (p.op === "or") {
             let pass = false;
-            let unknown3 = false;
+            let unknown2 = 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 (r === void 0) unknown2 = true;
             }
-            if (!pass && !unknown3) {
+            if (!pass && !unknown2) {
               out.push({
                 severity: "error",
                 code: "nudo:constraint-violated",
@@ -5884,34 +5277,6 @@ export {
   sidecarPathOf,
   createDiagChannel,
   createScopedDiagChannel,
-  SELF,
-  getTerm,
-  lenTerm,
-  isNudoConstraint,
-  isIntFlag,
-  number,
-  string,
-  boolean,
-  any,
-  array,
-  shape,
-  litC,
-  union,
-  nullable,
-  constraintAdmitsNullish,
-  fn,
-  andC,
-  partial,
-  pick,
-  omit,
-  CONSTRAINT_BUILDERS,
-  CONSTRAINT_BUILDER_NAMES,
-  CONSTRAINT_EXPR_RE,
-  instantiateConstraint,
-  instantiateOnTerm,
-  constraintToEntryAbs,
-  fnConstraintToEntryReqs,
-  throwConstraintToKinds,
   extractNudoImports,
   setRefineDiagCollector,
   refineDiagCount,
@@ -5957,7 +5322,6 @@ export {
   generalizeAll,
   listFunctionNames,
   buildArgsFromAssume,
-  literalMeetsConstraint,
   stableAnalyzeKeySource,
   listTopFunctions,
   scanLiteralCalls,