nudojs 1.3.11 → 1.3.13

package/dist/index.js

@@ -21662,12 +21662,16 @@ function nullishGuardOf(test) {
   if (t?.type === "UnaryExpression" && t.operator === "!") {
     const m = memberGuardTarget(t.argument);
     if (m) return { name: m.name, arm: "alt", grain: "nullish", memberKey: m.key };
+    const a = assignGuardTarget(t.argument);
+    if (a) return { name: a, arm: "alt", grain: "nullish" };
   }
   if (t?.type === "Identifier" && t.name) {
     return { name: t.name, arm: "cons", grain: "nullish" };
   }
   const bare = memberGuardTarget(t);
   if (bare) return { name: bare.name, arm: "cons", grain: "nullish", memberKey: bare.key };
+  const bareAssign = assignGuardTarget(t);
+  if (bareAssign) return { name: bareAssign, arm: "cons", grain: "nullish" };
   if (t?.type !== "BinaryExpression") return void 0;
   const op = t.operator;
   if (op !== "===" && op !== "!==" && op !== "==" && op !== "!=") return void 0;
@@ -21699,6 +21703,20 @@ function nullishGuardOf(test) {
     const grain = litGrain(l);
     if (grain !== void 0) return { name: r.name, arm: truthyArm, grain };
   }
+  if (op === "==" || op === "!=") {
+    const nullishLit = (n) => {
+      const ln = n;
+      return ln?.type === "NullLiteral" || ln?.name === "undefined";
+    };
+    const lm = memberGuardTarget(t.left);
+    const rm = memberGuardTarget(t.right);
+    if (lm && nullishLit(t.right)) {
+      return { name: lm.name, arm: truthyArm, grain: "nullish", memberKey: lm.key };
+    }
+    if (rm && nullishLit(t.left)) {
+      return { name: rm.name, arm: truthyArm, grain: "nullish", memberKey: rm.key };
+    }
+  }
   return void 0;
 }
 function compositeNullishGuardOf(test) {
@@ -21719,6 +21737,31 @@ function compositeNullishGuardOf(test) {
   }
   return lg ?? rg;
 }
+function mergeGuardInto(list, g) {
+  const prev = list.find((x) => x.name === g.name);
+  if (!prev) {
+    list.push(g);
+    return;
+  }
+  const grainA = prev.grain ?? "nullish";
+  const grainB = g.grain ?? "nullish";
+  if (grainA !== grainB) prev.grain = "nullish";
+  if (prev.memberKey === void 0 && g.memberKey !== void 0) prev.memberKey = g.memberKey;
+}
+function nullishGuardsOf(test) {
+  const t = test;
+  if (t?.type === "LogicalExpression" && (t.operator === "||" || t.operator === "&&")) {
+    const wantArm = t.operator === "||" ? "alt" : "cons";
+    const out = [];
+    for (const g2 of [...nullishGuardsOf(t.left), ...nullishGuardsOf(t.right)]) {
+      if (g2.arm !== wantArm) continue;
+      mergeGuardInto(out, g2);
+    }
+    return out;
+  }
+  const g = nullishGuardOf(test);
+  return g ? [g] : [];
+}
 function typeGuardOf(test) {
   const t = test;
   if (t?.type !== "BinaryExpression") return void 0;
@@ -21740,11 +21783,15 @@ function nullishRemoveCallOf(guard) {
   if (guard.grain === "null") return `$removeNull(${guard.name})`;
   return `$removeNullish(${guard.name})`;
 }
-function narrowNullishArmThunk(thunk, guard, arm, forkBindingNames) {
-  if (!guard || guard.arm !== arm) return thunk;
+function narrowNullishArmThunks(thunk, guards, arm, forkBindingNames) {
+  if (!guards || guards.length === 0) return thunk;
+  const matching = guards.filter((g) => g.arm === arm);
+  if (matching.length === 0) return thunk;
   const names2 = forkBindingNames instanceof Set ? forkBindingNames : new Set(forkBindingNames);
-  if (names2.has(guard.name)) return thunk;
-  return `((${guard.name}) => ${thunk})(${nullishRemoveCallOf(guard)})`;
+  if (matching.some((g) => names2.has(g.name))) return thunk;
+  const params = matching.map((g) => g.name).join(", ");
+  const args = matching.map((g) => nullishRemoveCallOf(g)).join(", ");
+  return `((${params}) => ${thunk})(${args})`;
 }
 function narrowTypeArmThunk(thunk, guard, arm, forkBindingNames) {
   if (!guard) return thunk;
@@ -21753,7 +21800,58 @@ function narrowTypeArmThunk(thunk, guard, arm, forkBindingNames) {
   const keep = arm === guard.arm;
   return `((${guard.name}) => ${thunk})($narrowTypeOf(${guard.name}, ${JSON.stringify(guard.typeOf)}, ${keep}))`;
 }
-var TYPEOF_NAMES2, isStrLitNode, typeofArgName, memberGuardTarget;
+function discriminantGuardOf(test) {
+  const t = test;
+  if (t?.type !== "BinaryExpression") return void 0;
+  if (t.operator !== "===" && t.operator !== "!==") return void 0;
+  const lm = memberGuardTarget(t.left);
+  const rm = memberGuardTarget(t.right);
+  const m = lm !== void 0 && isPrimLitNode(t.right) ? { target: lm, lit: t.right } : rm !== void 0 && isPrimLitNode(t.left) ? { target: rm, lit: t.left } : void 0;
+  if (!m) return void 0;
+  return {
+    name: m.target.name,
+    key: m.target.key,
+    value: m.lit.value,
+    arm: t.operator === "===" ? "cons" : "alt"
+  };
+}
+function discriminantGuardsOf(test) {
+  const t = test;
+  if (t?.type === "LogicalExpression" && (t.operator === "&&" || t.operator === "||")) {
+    const wantArm = t.operator === "&&" ? "cons" : "alt";
+    const out = [];
+    for (const g2 of [...discriminantGuardsOf(t.left), ...discriminantGuardsOf(t.right)]) {
+      if (g2.arm !== wantArm) continue;
+      if (out.some((x) => x.name === g2.name && x.key === g2.key && x.value === g2.value)) continue;
+      out.push(g2);
+    }
+    return out;
+  }
+  const g = discriminantGuardOf(test);
+  return g ? [g] : [];
+}
+function narrowDiscriminantArmThunks(thunk, guards, arm, forkBindingNames) {
+  if (!guards || guards.length === 0) return thunk;
+  const matching = guards.filter((g) => g.arm === arm);
+  if (matching.length === 0) return thunk;
+  const names2 = forkBindingNames instanceof Set ? forkBindingNames : new Set(forkBindingNames);
+  if (matching.some((g) => names2.has(g.name))) return thunk;
+  const byName = /* @__PURE__ */ new Map();
+  for (const g of matching) {
+    const list = byName.get(g.name) ?? [];
+    if (!list.some((x) => x.key === g.key && x.value === g.value)) list.push(g);
+    byName.set(g.name, list);
+  }
+  const params = [...byName.keys()].join(", ");
+  const args = [...byName.entries()].map(
+    ([name, gs]) => gs.reduce(
+      (acc, g) => `$narrowMemberEq(${acc}, ${JSON.stringify(g.key)}, ${JSON.stringify(g.value)}, true)`,
+      name
+    )
+  ).join(", ");
+  return `((${params}) => ${thunk})(${args})`;
+}
+var TYPEOF_NAMES2, isStrLitNode, typeofArgName, memberGuardTarget, assignGuardTarget, isPrimLitNode;
 var init_stmt_predicates = __esm({
   "../core/src/algebra/exec/transpile/stmt-predicates.ts"() {
     "use strict";
@@ -21790,6 +21888,20 @@ var init_stmt_predicates = __esm({
       if (key === void 0) return void 0;
       return { name: m.object.name, key };
     };
+    assignGuardTarget = (n) => {
+      const t = n;
+      if (t?.type === "AssignmentExpression" && t.operator === "=" && t.left?.type === "Identifier" && t.left.name) {
+        return t.left.name;
+      }
+      return void 0;
+    };
+    isPrimLitNode = (n) => {
+      const t = n;
+      if (t?.type === "StringLiteral") return typeof t.value === "string";
+      if (t?.type === "NumericLiteral") return typeof t.value === "number";
+      if (t?.type === "BooleanLiteral") return typeof t.value === "boolean";
+      return false;
+    };
   }
 });
 
@@ -21885,16 +21997,22 @@ function transpileFnBodyStmts(stmtsIn, depth, opts, varScope) {
     };
     const testRecvs = collectArrMutatorReceivers(stmt.test);
     const testRebinds = testRecvs.size ? emitArrMutatorRebinds(stmt.test, scopedOpts, pad) : [];
-    const earlyGuard = nullishGuardOf(stmt.test);
+    const earlyGuards = nullishGuardsOf(stmt.test);
     const earlyTGuard = typeGuardOf(stmt.test);
-    const consNarrowed = narrowTypeArmThunk(
-      narrowNullishArmThunk(
-        transpileBlockAsThunk(stmt.consequent, depth, scopedOpts),
-        earlyGuard,
+    const earlyDGuards = discriminantGuardsOf(stmt.test);
+    const consNarrowed = narrowDiscriminantArmThunks(
+      narrowTypeArmThunk(
+        narrowNullishArmThunks(
+          transpileBlockAsThunk(stmt.consequent, depth, scopedOpts),
+          earlyGuards,
+          "cons",
+          recvSet
+        ),
+        earlyTGuard,
         "cons",
         recvSet
       ),
-      earlyTGuard,
+      earlyDGuards,
       "cons",
       recvSet
     );
@@ -21903,9 +22021,14 @@ function transpileFnBodyStmts(stmtsIn, depth, opts, varScope) {
     const altThunk = `() => {
 ${altBody}
 ${pad}}`;
-    const altNarrowed = narrowTypeArmThunk(
-      narrowNullishArmThunk(altThunk, earlyGuard, "alt", recvSet),
-      earlyTGuard,
+    const altNarrowed = narrowDiscriminantArmThunks(
+      narrowTypeArmThunk(
+        narrowNullishArmThunks(altThunk, earlyGuards, "alt", recvSet),
+        earlyTGuard,
+        "alt",
+        recvSet
+      ),
+      earlyDGuards,
       "alt",
       recvSet
     );
@@ -22234,17 +22357,28 @@ ${pad}export default ${name};`;
         ...opts,
         conditionalFlow: (opts.conditionalFlow ?? 0) + 1
       }) : null;
-      const guard = nullishGuardOf(stmt.test);
+      const guards = nullishGuardsOf(stmt.test);
       const tguard = typeGuardOf(stmt.test);
-      const consNarrowed = narrowTypeArmThunk(
-        narrowNullishArmThunk(consRaw, guard, "cons", recvSet),
-        tguard,
+      const dguards = discriminantGuardsOf(stmt.test);
+      const consNarrowed = narrowDiscriminantArmThunks(
+        narrowTypeArmThunk(
+          narrowNullishArmThunks(consRaw, guards, "cons", recvSet),
+          tguard,
+          "cons",
+          recvSet
+        ),
+        dguards,
         "cons",
         recvSet
       );
-      const altNarrowed = altRaw === null ? null : narrowTypeArmThunk(
-        narrowNullishArmThunk(altRaw, guard, "alt", recvSet),
-        tguard,
+      const altNarrowed = altRaw === null ? null : narrowDiscriminantArmThunks(
+        narrowTypeArmThunk(
+          narrowNullishArmThunks(altRaw, guards, "alt", recvSet),
+          tguard,
+          "alt",
+          recvSet
+        ),
+        dguards,
         "alt",
         recvSet
       );
@@ -22691,13 +22825,24 @@ ${indent(depth + 1)}]${dflt})`;
       collectAssignedIds(stmt.test, assigned);
       const bodyLocalDecls = /* @__PURE__ */ new Set();
       collectLoopBodyTopLevelDeclNames(stmt.body, bodyLocalDecls);
+      const bodyWrites = /* @__PURE__ */ new Set();
+      collectAssignedIds(stmt.body, bodyWrites);
+      collectArrMutatorReceivers(stmt.body, bodyWrites);
+      const loopGuards = nullishGuardsOf(stmt.test).filter(
+        (g) => g.arm === "cons" && !bodyWrites.has(g.name) && !bodyLocalDecls.has(g.name)
+      );
+      const bodyNarrowed = loopGuards.length === 0 ? body : [
+        `${indent(depth + 1)}((${loopGuards.map((g) => g.name).join(", ")}) => {`,
+        body,
+        `${indent(depth + 1)}})(${loopGuards.map((g) => nullishRemoveCallOf(g)).join(", ")});`
+      ].join("\n");
       const names2 = [...assigned].filter((n) => !HOST_INTRINSIC_SET.has(n) && !bodyLocalDecls.has(n));
       const loopOpts = opts.loopLabel ? `label: ${JSON.stringify(opts.loopLabel)}` : "";
       if (names2.length === 0) {
         return [
           `${pad}// while \u2192 $whileSeq (bounded, max=${max})`,
           `${pad}$whileSeq(() => ${test}, () => {`,
-          body,
+          bodyNarrowed,
           `${pad}}, ${max}${loopOpts ? `, { ${loopOpts} }` : ""});`
         ].join("\n");
       }
@@ -22706,7 +22851,7 @@ ${indent(depth + 1)}]${dflt})`;
       return [
         `${pad}// while \u2192 $whileSeq (instrumented bindings: ${names2.join(", ")})`,
         `${pad}$whileSeq(() => ${test}, () => {`,
-        body,
+        bodyNarrowed,
         `${pad}}, ${max}, { pack: () => ${packSrc}, unpack: ${unpackSrc}${loopOpts ? `, ${loopOpts}` : ""} });`
       ].join("\n");
     }
@@ -22725,6 +22870,17 @@ ${indent(depth + 1)}]${dflt})`;
       collectArrMutatorReceivers(stmt.body, assigned);
       const bodyLocalDecls = /* @__PURE__ */ new Set();
       collectLoopBodyTopLevelDeclNames(stmt.body, bodyLocalDecls);
+      const bodyWrites = /* @__PURE__ */ new Set();
+      collectAssignedIds(stmt.body, bodyWrites);
+      collectArrMutatorReceivers(stmt.body, bodyWrites);
+      const loopGuards = nullishGuardsOf(stmt.test).filter(
+        (g) => g.arm === "cons" && !bodyWrites.has(g.name) && !bodyLocalDecls.has(g.name)
+      );
+      const innerBody = loopGuards.length === 0 ? bodyStmts : [
+        `${indent(depth + 1)}((${loopGuards.map((g) => g.name).join(", ")}) => {`,
+        bodyStmts,
+        `${indent(depth + 1)}})(${loopGuards.map((g) => nullishRemoveCallOf(g)).join(", ")});`
+      ].join("\n");
       const names2 = [...assigned].filter((n) => !HOST_INTRINSIC_SET.has(n) && !bodyLocalDecls.has(n));
       const packSrc = names2.length === 0 ? null : `$obj({ ${names2.map((n) => `${JSON.stringify(n)}: $copy(${n})`).join(", ")} })`;
       const unpackSrc = names2.length === 0 ? null : `(__lp) => { ${names2.map((n) => `${n} = $get(__lp, ${JSON.stringify(n)});`).join(" ")} }`;
@@ -22735,7 +22891,7 @@ ${indent(depth + 1)}]${dflt})`;
         `{`,
         bodyStmts,
         `${indent(depth + 1)}$whileSeq(() => ${test}, () => {`,
-        bodyStmts,
+        innerBody,
         `${indent(depth + 1)}}, ${max}${optsSrc});`,
         `${pad}}`
       ].join("\n");
@@ -23156,27 +23312,42 @@ function transpileShortCircuitExpr(opts, parts) {
     const forkTest2 = parts.testSrc ?? parts.alwaysSrc;
     let consExpr = parts.consSrc === "__test" ? parts.alwaysSrc : parts.consSrc;
     let altExpr = parts.altSrc === "__test" ? parts.alwaysSrc : parts.altSrc;
-    if (parts.narrowGuard) {
-      if (parts.narrowGuard.arm === "cons") {
-        consExpr = `((${parts.narrowGuard.name}) => (${consExpr}))(${nullishRemoveCallOf(parts.narrowGuard)})`;
-      } else {
-        altExpr = `((${parts.narrowGuard.name}) => (${altExpr}))(${nullishRemoveCallOf(parts.narrowGuard)})`;
-      }
-    }
+    const applyGuards = (src, arm) => {
+      const gs = (parts.narrowGuards ?? []).filter((g) => g.arm === arm);
+      if (gs.length === 0) return src;
+      const params = gs.map((g) => g.name).join(", ");
+      const args = gs.map((g) => nullishRemoveCallOf(g)).join(", ");
+      return `((${params}) => (${src}))(${args})`;
+    };
+    consExpr = applyGuards(consExpr, "cons");
+    altExpr = applyGuards(altExpr, "alt");
     if (parts.typeGuard) {
       const g = parts.typeGuard;
       const apply = (src, arm) => `((${g.name}) => (${src}))($narrowTypeOf(${g.name}, ${JSON.stringify(g.typeOf)}, ${arm === g.arm}))`;
       consExpr = apply(consExpr, "cons");
       altExpr = apply(altExpr, "alt");
     }
+    const applyDisc = (src, arm) => narrowDiscriminantArmThunks(src, parts.discGuards, arm, []);
+    consExpr = applyDisc(consExpr, "cons");
+    altExpr = applyDisc(altExpr, "alt");
     return `$fork(${forkTest2}, () => ${consExpr}, () => ${altExpr})`;
   }
   const consLines = parts.consSrc === "__test" ? [`return __test;`] : consRebinds.length === 0 ? [`return (${parts.consSrc});`] : [`const __v = (${parts.consSrc});`, ...consRebinds, `return __v;`];
   const altLines = parts.altSrc === "__test" ? [`return __test;`] : altRebinds.length === 0 ? [`return (${parts.altSrc});`] : [`const __v = (${parts.altSrc});`, ...altRebinds, `return __v;`];
   const forkTest = parts.testSrc ?? "__test";
-  const guard = parts.narrowGuard;
-  const consFinal = narrowNullishArmThunk(forkArmThunk(consLines, "fk1_", names2), guard, "cons", names2);
-  const altFinal = narrowNullishArmThunk(forkArmThunk(altLines, "fk2_", names2), guard, "alt", names2);
+  const guards = parts.narrowGuards;
+  const consFinal = narrowDiscriminantArmThunks(
+    narrowNullishArmThunks(forkArmThunk(consLines, "fk1_", names2), guards, "cons", names2),
+    parts.discGuards,
+    "cons",
+    names2
+  );
+  const altFinal = narrowDiscriminantArmThunks(
+    narrowNullishArmThunks(forkArmThunk(altLines, "fk2_", names2), guards, "alt", names2),
+    parts.discGuards,
+    "alt",
+    names2
+  );
   return [
     `(() => {`,
     `  const __test = (${parts.alwaysSrc});`,
@@ -23398,8 +23569,9 @@ ${inner}
           testSrc: `$nullishTest(${l})`
         });
       }
-      const andGuard = nullishGuardOf(expr.left);
+      const leftGuards = nullishGuardsOf(expr.left);
       const andTypeGuard = typeGuardOf(expr.left);
+      const leftDiscGuards = discriminantGuardsOf(expr.left);
       return op === "&&" ? transpileShortCircuitExpr(opts, {
         alwaysNodes: [lNode],
         alwaysSrc: l,
@@ -23407,8 +23579,9 @@ ${inner}
         consNodes: [rNode],
         altSrc: "__test",
         altNodes: [],
-        narrowGuard: andGuard?.arm === "cons" ? andGuard : void 0,
-        typeGuard: andTypeGuard
+        narrowGuards: leftGuards.filter((g) => g.arm === "cons"),
+        typeGuard: andTypeGuard,
+        discGuards: leftDiscGuards.filter((g) => g.arm === "cons")
       }) : transpileShortCircuitExpr(opts, {
         alwaysNodes: [lNode],
         alwaysSrc: l,
@@ -23416,8 +23589,9 @@ ${inner}
         consNodes: [],
         altSrc: r,
         altNodes: [rNode],
-        narrowGuard: andGuard?.arm === "alt" ? andGuard : void 0,
-        typeGuard: andTypeGuard
+        narrowGuards: leftGuards.filter((g) => g.arm === "alt"),
+        typeGuard: andTypeGuard,
+        discGuards: leftDiscGuards.filter((g) => g.arm === "alt")
       });
     }
     case "ConditionalExpression": {
@@ -23435,9 +23609,12 @@ ${inner}
         altSrc: a,
         altNodes: [altNode],
         // 三元的 nullish/typeof 守卫臂收窄（issue #97：`p === null ? -1 : p.major`；
-        // Bug 23：`typeof v === "string" ? v + "!" : 0`）
-        narrowGuard: nullishGuardOf(expr.test),
-        typeGuard: typeGuardOf(expr.test)
+        // Bug 23：`typeof v === "string" ? v + "!" : 0`；#118 v3/#120：多名复合
+        // `obj == null || node.p == null ? … : node.p.name` 一臂多事实）；
+        // 判别等值守卫（issue #126）：`node.type === 'TL' ? node.quasis[0] : null`
+        narrowGuards: nullishGuardsOf(expr.test),
+        typeGuard: typeGuardOf(expr.test),
+        discGuards: discriminantGuardsOf(expr.test)
       });
     }
     case "RegExpLiteral": {
@@ -24194,7 +24371,7 @@ function transpileSource(source, opts = {}) {
   return transpileFile(file, { ...opts, source: opts.source ?? source });
 }
 function runtimeImportOf(runtime) {
-  return `import { $absVal, $add, $sub, $mul, $div, $mod, $bitand, $bitor, $bitxor, $bitnot, $shl, $shr, $ushr, $pow, $toNumber, $toNumeric, $updateAdd, $updateSub, $in, $instanceof, $instanceofNonIdent, $classExpr, $del, $delRes, $objAccessor, $objAccessorKey, $neg, $typeof, $not, $eq, $ne, $eqLoose, $neLoose, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $setProto, $while, $whileSeq, $arr, $arrWithHoles, $arrMutContainer, $idx, $idxSet, $len, $call, $throw, $loopReturn, $loopBreak, $loopContinue, $class, $new, $invoke, $invokeSuper, $invokeSuperObj, $invokeSuperKey, $getSuper, $getSuperObj, $super, $async, $copy, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $forInKeys, $iterCheck, $catchVal, $switch, $staticInvoke, $setKey, $gen, $newTarget, $staticInit, $yield, $fnVal, $regex, $reStateCall, $rethrowIfNudoReturn, $nullishTest, $removeNullish, $removeNull, $removeUndefined, $removeMemberNullish, $narrowTypeOf, $tryMark, $assignRecord, $recordBinding, $unknown, $importMeta, $dynamicImport, $tryTakeSince, $tryCurrentMark, $tryPopMark, $tryDigestSoftCatch, $tryReleaseSoftOut, $tryDetachSoftCatch, $tryDiscardSoft, $tryOrphanSoft, $pushLoopExit, $objRest, $arrRest, $elems, $arguments, $isForkExit, $rawThis, $isBreakTo, $yieldStar, $tpl } from ${JSON.stringify(runtime)};`;
+  return `import { $absVal, $add, $sub, $mul, $div, $mod, $bitand, $bitor, $bitxor, $bitnot, $shl, $shr, $ushr, $pow, $toNumber, $toNumeric, $updateAdd, $updateSub, $in, $instanceof, $instanceofNonIdent, $classExpr, $del, $delRes, $objAccessor, $objAccessorKey, $neg, $typeof, $not, $eq, $ne, $eqLoose, $neLoose, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $setProto, $while, $whileSeq, $arr, $arrWithHoles, $arrMutContainer, $idx, $idxSet, $len, $call, $throw, $loopReturn, $loopBreak, $loopContinue, $class, $new, $invoke, $invokeSuper, $invokeSuperObj, $invokeSuperKey, $getSuper, $getSuperObj, $super, $async, $copy, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $forInKeys, $iterCheck, $catchVal, $switch, $staticInvoke, $setKey, $gen, $newTarget, $staticInit, $yield, $fnVal, $regex, $reStateCall, $rethrowIfNudoReturn, $nullishTest, $removeNullish, $removeNull, $removeUndefined, $removeMemberNullish, $narrowMemberEq, $narrowTypeOf, $tryMark, $assignRecord, $recordBinding, $unknown, $importMeta, $dynamicImport, $tryTakeSince, $tryCurrentMark, $tryPopMark, $tryDigestSoftCatch, $tryReleaseSoftOut, $tryDetachSoftCatch, $tryDiscardSoft, $tryOrphanSoft, $pushLoopExit, $objRest, $arrRest, $elems, $arguments, $isForkExit, $rawThis, $isBreakTo, $yieldStar, $tpl } from ${JSON.stringify(runtime)};`;
 }
 function transpileFile(file, opts = {}) {
   const runtime = opts.runtimeImport ?? "@nudojs/core/exec";
@@ -24215,7 +24392,7 @@ function transpileFile(file, opts = {}) {
   };
   const lines = [
     `// nudo evaluator transpile \u2014 values are Abs; operators are overloaded calls`,
-    `import { $absVal, $add, $sub, $mul, $div, $mod, $bitand, $bitor, $bitxor, $bitnot, $shl, $shr, $ushr, $pow, $toNumber, $toNumeric, $updateAdd, $updateSub, $in, $instanceof, $instanceofNonIdent, $classExpr, $del, $delRes, $objAccessor, $objAccessorKey, $neg, $typeof, $not, $eq, $ne, $eqLoose, $neLoose, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $setProto, $while, $whileSeq, $arr, $arrWithHoles, $arrMutContainer, $idx, $idxSet, $len, $call, $throw, $loopReturn, $loopBreak, $loopContinue, $class, $new, $invoke, $invokeSuper, $invokeSuperObj, $invokeSuperKey, $getSuper, $getSuperObj, $super, $async, $copy, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $forInKeys, $iterCheck, $catchVal, $switch, $staticInvoke, $setKey, $gen, $newTarget, $staticInit, $yield, $fnVal, $regex, $reStateCall, $rethrowIfNudoReturn, $nullishTest, $removeNullish, $removeNull, $removeUndefined, $removeMemberNullish, $narrowTypeOf, $tryMark, $assignRecord, $recordBinding, $unknown, $importMeta, $dynamicImport, $tryTakeSince, $tryCurrentMark, $tryPopMark, $tryDigestSoftCatch, $tryReleaseSoftOut, $tryDetachSoftCatch, $tryDiscardSoft, $tryOrphanSoft, $pushLoopExit, $objRest, $arrRest, $elems, $arguments, $isForkExit, $rawThis, $isBreakTo, $yieldStar, $tpl } from ${JSON.stringify(runtime)};`,
+    `import { $absVal, $add, $sub, $mul, $div, $mod, $bitand, $bitor, $bitxor, $bitnot, $shl, $shr, $ushr, $pow, $toNumber, $toNumeric, $updateAdd, $updateSub, $in, $instanceof, $instanceofNonIdent, $classExpr, $del, $delRes, $objAccessor, $objAccessorKey, $neg, $typeof, $not, $eq, $ne, $eqLoose, $neLoose, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $setProto, $while, $whileSeq, $arr, $arrWithHoles, $arrMutContainer, $idx, $idxSet, $len, $call, $throw, $loopReturn, $loopBreak, $loopContinue, $class, $new, $invoke, $invokeSuper, $invokeSuperObj, $invokeSuperKey, $getSuper, $getSuperObj, $super, $async, $copy, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $forInKeys, $iterCheck, $catchVal, $switch, $staticInvoke, $setKey, $gen, $newTarget, $staticInit, $yield, $fnVal, $regex, $reStateCall, $rethrowIfNudoReturn, $nullishTest, $removeNullish, $removeNull, $removeUndefined, $removeMemberNullish, $narrowMemberEq, $narrowTypeOf, $tryMark, $assignRecord, $recordBinding, $unknown, $importMeta, $dynamicImport, $tryTakeSince, $tryCurrentMark, $tryPopMark, $tryDigestSoftCatch, $tryReleaseSoftOut, $tryDetachSoftCatch, $tryDiscardSoft, $tryOrphanSoft, $pushLoopExit, $objRest, $arrRest, $elems, $arguments, $isForkExit, $rawThis, $isBreakTo, $yieldStar, $tpl } from ${JSON.stringify(runtime)};`,
     ``
   ];
   if (varHoistLine) lines.push(varHoistLine);
@@ -25685,6 +25862,8 @@ function $copy(a) {
       open: s.open
     });
     next.conf = a.conf;
+    next.term = a.term;
+    next.pred = a.pred;
     migrateAccessors(a, next);
     migrateInvariants(a, next);
     migrateNullProto(a, next);
@@ -28243,6 +28422,58 @@ function $narrowTypeOf(a, typeOf2, keep) {
   if (kept.length === 0) return a;
   return kept.length === 1 ? kept[0] : { ...a, shape: { k: "sum", members: kept } };
 }
+function litRefutesEq(other, v2) {
+  return other !== v2;
+}
+function memberEqClass(m, key, litAbs, value) {
+  const sh = m.shape;
+  if (sh.k === "obj") {
+    const slots = sh.slots;
+    if (!Object.prototype.hasOwnProperty.call(slots, key)) {
+      return sh.open ? "may" : "never";
+    }
+    const slotValue = slots[key].value;
+    if (slotValue.shape.k === "any" || slotValue.shape.k === "unknown") return "may";
+    const shapeOnly = (s) => abs(s, void 0, void 0, "exact");
+    if (!leqAbs(shapeOnly(litAbs.shape), shapeOnly(slotValue.shape)).ok) return "never";
+    const t = slotValue.term;
+    const p = slotValue.pred;
+    if (!t || !p || p.op === "true") return "may";
+    const litTerm = lit(value);
+    if (implies(p, { op: "eq", a: t, b: litTerm })) return "only";
+    if (implies(p, { op: "ne", a: t, b: litTerm })) return "never";
+    const conjuncts = [];
+    const visit2 = (c) => {
+      if (c.op === "and") {
+        c.args.forEach(visit2);
+        return;
+      }
+      conjuncts.push(c);
+    };
+    visit2(p);
+    for (const c of conjuncts) {
+      if (c.op !== "eq") continue;
+      const other = termEquals(c.a, t) && c.b.op === "lit" ? c.b.value : termEquals(c.b, t) && c.a.op === "lit" ? c.a.value : void 0;
+      if (other !== void 0 && litRefutesEq(other, value)) return "never";
+    }
+    return "may";
+  }
+  if (m.term?.op === "lit") return "never";
+  return "may";
+}
+function $narrowMemberEq(a, key, value, keep) {
+  if (!a || typeof a !== "object" || !("shape" in a)) return a;
+  if (a.shape.k !== "sum") return a;
+  const litAbs = typeof value === "string" ? strLit(value) : typeof value === "number" ? numLit(value) : boolLit(value);
+  const members = a.shape.members;
+  const kept = members.filter((m) => {
+    const c = memberEqClass(m, key, litAbs, value);
+    return keep ? c !== "never" : c !== "only";
+  });
+  if (kept.length === members.length) return a;
+  if (kept.length === 0) return a;
+  return kept.length === 1 ? kept[0] : { ...a, shape: { k: "sum", members: kept } };
+}
 function primShapeOfTypeOf(typeOf2) {
   switch (typeOf2) {
     case "string":
@@ -28267,7 +28498,10 @@ var init_async = __esm({
   "../core/src/algebra/exec/runtime/async.ts"() {
     "use strict";
     init_abs();
+    init_term();
+    init_pred();
     init_objects();
+    init_leq();
     init_abs_fn();
     init_surface();
     init_state();
@@ -28337,6 +28571,7 @@ __export(runtime_exports, {
   $lt: () => $lt,
   $mod: () => $mod,
   $mul: () => $mul,
+  $narrowMemberEq: () => $narrowMemberEq,
   $narrowTypeOf: () => $narrowTypeOf,
   $ne: () => $ne,
   $neLoose: () => $neLoose,
@@ -28489,6 +28724,800 @@ var init_lru_map = __esm({
   }
 });
 
+// ../core/src/algebra/constraint.ts
+function selfTerm() {
+  return v(SELF);
+}
+function getTerm(obj2, key) {
+  return app("get", [obj2, lit(key)]);
+}
+function lenTerm(t) {
+  return app("length", [t]);
+}
+function isConstraint(x) {
+  return !!x && typeof x === "object" && x.__nudoConstraint === true;
+}
+function isNudoConstraint(x) {
+  return isConstraint(x);
+}
+function isIntFlag(c) {
+  return c.int === true || intFlaggedBuilders.has(c);
+}
+function makeBuilder(prim2, 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 lazySlot = extra?.lazy;
+  const base = {
+    __nudoConstraint: true,
+    ...prim2 ? { prim: prim2 } : {},
+    preds: [...preds],
+    ...fields ? { fields } : {},
+    ...element ? { element } : {},
+    ...optional ? { isOptional: true } : {},
+    ...members ? { members } : {},
+    ...fnSlot ? { fn: fnSlot } : {},
+    ...lazySlot ? { lazy: lazySlot } : {}
+  };
+  const add2 = (p) => makeBuilder(prim2, [...preds, p], extra);
+  const builder = Object.assign(
+    /* @__PURE__ */ Object.create(null),
+    base,
+    {
+      gt: (n) => add2(gt(selfTerm(), lit(n))),
+      ge: (n) => add2(ge(selfTerm(), lit(n))),
+      lt: (n) => add2(lt(selfTerm(), lit(n))),
+      le: (n) => add2(le(selfTerm(), lit(n))),
+      int: () => makeBuilder(prim2 ?? "number", preds, { ...extra, int: true }),
+      min: (n) => add2(ge(lenTerm(selfTerm()), lit(n))),
+      max: (n) => add2(le(lenTerm(selfTerm()), lit(n))),
+      length: (n) => add2(and(ge(lenTerm(selfTerm()), lit(n)), le(lenTerm(selfTerm()), lit(n)))),
+      shift: (n) => {
+        if (!Number.isFinite(n))
+          throw new Error("nudo shift(): offset must be a finite number");
+        if (fields || element || members || fnSlot || lazySlot)
+          throw new Error("nudo shift(): only numeric scalar constraint chains are allowed (shape/array/union/fn are not supported)");
+        if (prim2 !== void 0 && prim2 !== "number")
+          throw new Error(`nudo shift(): only numeric chains are allowed (prim=${prim2})`);
+        return makeBuilder(prim2, shiftBoundPreds(preds, n), extra);
+      },
+      optional: () => makeBuilder(prim2, 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 } : {},
+    ...c.lazy ? { lazy: c.lazy } : {}
+  };
+}
+function litC(v2) {
+  const prim2 = typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : typeof v2 === "boolean" ? "boolean" : void 0;
+  return makeBuilder(prim2, [eq(selfTerm(), lit(v2))]);
+}
+function asNestedConstraint(x, ctx2) {
+  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: ${ctx2} 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 lazy(thunk) {
+  if (typeof thunk !== "function")
+    throw new Error("nudo lazy(): expects a thunk function () => constraint");
+  return makeBuilder(void 0, [], { lazy: thunk });
+}
+function derefConstraint(c) {
+  const thunk = c.lazy;
+  if (!thunk) return c;
+  const memoized = lazyDerefMemo.get(thunk);
+  if (memoized) return memoized;
+  const out = thunk();
+  if (!isConstraint(out))
+    throw new Error(
+      "nudo lazy(): the thunk must return a constraint (number()/string()/shape()/\u2026)"
+    );
+  const normalized = toPlainConstraint(out);
+  lazyDerefMemo.set(thunk, normalized);
+  return normalized;
+}
+function constraintAdmitsNullish(c, seen) {
+  if (c.lazy) {
+    const s = seen ?? /* @__PURE__ */ new Set();
+    if (s.has(c.lazy)) return false;
+    s.add(c.lazy);
+    return constraintAdmitsNullish(derefConstraint(c), s);
+  }
+  if (c.members)
+    return c.members.some((m) => constraintAdmitsNullish(m, seen));
+  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 prim2;
+  let isInt = false;
+  let allOptional = true;
+  const preds = [];
+  for (const c0 of cs) {
+    if (!isConstraint(c0))
+      throw new Error("nudo: expected a constraint value (number()/string()/\u2026 or a combinator)");
+    const c = derefConstraint(c0);
+    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 (prim2 !== void 0 && prim2 !== c.prim)
+        throw new Error(`nudo and(): inconsistent prim (${prim2} vs ${c.prim})`);
+      prim2 = c.prim;
+    }
+    preds.push(...c.preds);
+    if (isIntFlag(c)) isInt = true;
+    if (!c.isOptional) allOptional = false;
+  }
+  return makeBuilder(prim2, preds, {
+    ...isInt ? { int: true } : {},
+    ...allOptional ? { optional: true } : {}
+  });
+}
+function partial(c) {
+  if (!isConstraint(c))
+    throw new Error("nudo partial(): only shape(...) constraints are accepted");
+  const d = derefConstraint(c);
+  if (!d.fields)
+    throw new Error("nudo partial(): only shape(...) constraints are accepted");
+  const fields = {};
+  for (const [k, f] of Object.entries(d.fields)) {
+    fields[k] = {
+      constraint: { ...toPlainConstraint(f.constraint), isOptional: true },
+      optional: true
+    };
+  }
+  return makeBuilder(d.prim, d.preds, { fields });
+}
+function pick(c, keys) {
+  if (!isConstraint(c))
+    throw new Error("nudo pick(): only shape(...) constraints are accepted");
+  const d = derefConstraint(c);
+  if (!d.fields)
+    throw new Error("nudo pick(): only shape(...) constraints are accepted");
+  const fields = {};
+  for (const k of keys) {
+    const f = d.fields[k];
+    if (f) fields[k] = f;
+  }
+  return makeBuilder(d.prim, d.preds, { fields });
+}
+function omit(c, keys) {
+  if (!isConstraint(c))
+    throw new Error("nudo omit(): only shape(...) constraints are accepted");
+  const d = derefConstraint(c);
+  if (!d.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(d.fields)) {
+    if (!drop.has(k)) fields[k] = f;
+  }
+  return makeBuilder(d.prim, d.preds, { fields });
+}
+function substTerm(t, paramName2) {
+  if (t.op === "var" && t.id === SELF) return v(paramName2);
+  if (t.op === "app" && t.fn === "get" && t.args.length === 2) {
+    return getTerm(substTerm(t.args[0], paramName2), String(
+      t.args[1].op === "lit" ? t.args[1].value : ""
+    ));
+  }
+  return t;
+}
+function substPred2(p, paramName2) {
+  switch (p.op) {
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+    case "eq":
+    case "ne": {
+      return { op: p.op, a: substTerm(p.a, paramName2), b: substTerm(p.b, paramName2) };
+    }
+    case "typeof": {
+      return { op: "typeof", t: substTerm(p.t, paramName2), type: p.type };
+    }
+    case "and":
+      return and(...p.args.map((x) => substPred2(x, paramName2)));
+    default:
+      return p;
+  }
+}
+function instantiateConstraint(c, paramName2, depth = LAZY_TEMPLATE_DEPTH) {
+  if (c.lazy) {
+    if (depth <= 0) return pTrue;
+    return instantiateConstraint(derefConstraint(c), paramName2, depth - 1);
+  }
+  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(paramName2), key);
+      parts.push(instantiateOnTerm(field.constraint, fieldTerm, depth));
+    }
+    if (c.prim) parts.push(ptypeof(v(paramName2), 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(paramName2), depth))
+    );
+    const own = c.preds.map((p) => substPred2(p, paramName2));
+    return own.length === 0 ? disj : and(...own, disj);
+  }
+  if (c.fn) {
+    const own = c.preds.map((p) => substPred2(p, paramName2));
+    return own.length === 0 ? pTrue : and(...own);
+  }
+  const preds = c.preds.map((p) => substPred2(p, paramName2));
+  if (c.prim && c.preds.length === 0) {
+    return ptypeof(v(paramName2), primToTypeof(c.prim));
+  }
+  return preds.length === 0 ? { op: "true" } : preds.length === 1 ? preds[0] : and(...preds);
+}
+function instantiateOnTerm(c, t, depth = LAZY_TEMPLATE_DEPTH) {
+  if (c.lazy) {
+    if (depth <= 0) return pTrue;
+    return instantiateOnTerm(derefConstraint(c), t, depth - 1);
+  }
+  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 tt2 = p.t.op === "var" && p.t.id === SELF ? t : p.t;
+        return { op: "typeof", t: tt2, 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), depth));
+    }
+    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, depth)));
+    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, paramName2, depth = LAZY_TEMPLATE_DEPTH) {
+  const t = v(paramName2);
+  if (c.fields) {
+    const slots = {};
+    for (const [key, field] of Object.entries(c.fields)) {
+      if (field.constraint.lazy && depth <= 0) continue;
+      const fieldTerm = getTerm(t, key);
+      slots[key] = {
+        value: constraintOnTermAbs(field.constraint, fieldTerm, depth),
+        ...field.optional || field.constraint.isOptional ? { optional: true } : {}
+      };
+    }
+    return abs({ k: "obj", slots }, t, void 0, "path");
+  }
+  return constraintOnTermAbs(c, t, depth);
+}
+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 prim2;
+  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 (prim2 === void 0) prim2 = mp;
+    else if (prim2 !== mp) return void 0;
+    values.push(v2);
+  }
+  if (prim2 === 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: prim2 }, t, disj, "path");
+}
+function constraintOnTermAbs(c, t, depth) {
+  if (c.lazy) {
+    if (depth <= 0) return abs({ k: "any" }, t, void 0, "path");
+    return constraintOnTermAbs(derefConstraint(c), t, depth - 1);
+  }
+  if (c.fields) {
+    const slots = {};
+    for (const [key, field] of Object.entries(c.fields)) {
+      if (field.constraint.lazy && depth <= 0) continue;
+      slots[key] = {
+        value: constraintOnTermAbs(field.constraint, getTerm(t, key), depth),
+        ...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, depth)).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}`), depth)
+    );
+    const returnType = c.fn.returns ? constraintOnTermAbs(c.fn.returns, v("ret"), depth) : unknown;
+    return abs(
+      { k: "fn", params: paramNames, paramTypes, returnType },
+      t,
+      void 0,
+      "path"
+    );
+  }
+  if (c.element) {
+    const elem = constraintOnTermAbs(c.element, v("x[]"), depth);
+    return abs({ k: "arr", element: elem }, t, void 0, "path");
+  }
+  const pred = instantiateOnTerm(c, t, depth);
+  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 seen = /* @__PURE__ */ new Set();
+  const note2 = (s) => {
+    if (s === "*" || s === "any") any2 = true;
+    else if (s) out.add(s);
+  };
+  const walk = (x) => {
+    if (x.lazy) {
+      if (seen.has(x.lazy)) return;
+      seen.add(x.lazy);
+      walk(derefConstraint(x));
+      return;
+    }
+    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") note2(side.value);
+      }
+    }
+  };
+  walk(c);
+  if (any2) return "*";
+  if (out.size > 0) return [...out];
+  return void 0;
+}
+var SELF, intFlaggedBuilders, LAZY_TEMPLATE_DEPTH, lazyDerefMemo, CONSTRAINT_BUILDERS, CONSTRAINT_BUILDER_NAMES, CONSTRAINT_EXPR_RE;
+var init_constraint = __esm({
+  "../core/src/algebra/constraint.ts"() {
+    "use strict";
+    init_pred();
+    init_term();
+    init_abs();
+    init_objects();
+    SELF = "__nudo_self__";
+    intFlaggedBuilders = /* @__PURE__ */ new WeakSet();
+    LAZY_TEMPLATE_DEPTH = 3;
+    lazyDerefMemo = /* @__PURE__ */ new WeakMap();
+    CONSTRAINT_BUILDERS = {
+      number,
+      string,
+      boolean,
+      any,
+      array,
+      shape,
+      lit: litC,
+      union,
+      nullable,
+      lazy,
+      fn,
+      and: andC,
+      partial,
+      pick,
+      omit
+    };
+    CONSTRAINT_BUILDER_NAMES = Object.keys(
+      CONSTRAINT_BUILDERS
+    );
+    CONSTRAINT_EXPR_RE = new RegExp(
+      `^(${CONSTRAINT_BUILDER_NAMES.join("|")})\\s*\\(`
+    );
+  }
+});
+
+// ../core/src/algebra/domain-membership.ts
+function literalMeetsConstraint(lv, c, seen) {
+  if (c.lazy) {
+    const s = seen ?? /* @__PURE__ */ new Set();
+    if (s.has(c.lazy)) return false;
+    s.add(c.lazy);
+    return literalMeetsConstraint(lv, derefConstraint(c), s);
+  }
+  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, seen));
+  }
+  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(prim2, lv) {
+  switch (prim2) {
+    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]);
+}
+var init_domain_membership = __esm({
+  "../core/src/algebra/domain-membership.ts"() {
+    "use strict";
+    init_constraint();
+  }
+});
+
+// ../core/src/algebra/contract-face.ts
+function attachContractFaces(fnObj, faces) {
+  facesByFn.set(fnObj, faces);
+}
+function contractFacesOf(fnObj) {
+  if (!fnObj || typeof fnObj !== "object" && typeof fnObj !== "function") {
+    return void 0;
+  }
+  return facesByFn.get(fnObj);
+}
+function setContractFaceResolver(resolver) {
+  const prev = contractFaceResolverSlot.get();
+  contractFaceResolverSlot.set(resolver);
+  return prev;
+}
+function resolveContractFacesByName(fnName) {
+  const resolver = contractFaceResolverSlot.get();
+  return resolver ? resolver(fnName) : void 0;
+}
+function argLacksInformation(a) {
+  if (!a || typeof a !== "object" || !("shape" in a)) return false;
+  const k = a.shape?.k;
+  if (k === "any") return true;
+  if (k === "unknown") return a.term?.op !== "lit";
+  return false;
+}
+function adoptCallArgsToFaces(args, faces) {
+  const n = Math.min(args.length, faces.paramFaces.length);
+  let changed = false;
+  const out = args.slice();
+  for (let i = 0; i < n; i++) {
+    const face = faces.paramFaces[i];
+    if (!face || !argLacksInformation(args[i])) continue;
+    out[i] = face;
+    changed = true;
+  }
+  return changed ? out : args;
+}
+function litMeetsReturnConstraint(r, c) {
+  if (!c) return false;
+  const lv = litValue(r);
+  if (!lv.ok) return false;
+  const v2 = lv.value;
+  if (typeof v2 !== "number" && typeof v2 !== "string" && typeof v2 !== "boolean" && v2 !== null && v2 !== void 0) {
+    return false;
+  }
+  return literalMeetsConstraint(v2, c);
+}
+function presentCallResultFace(r, faces) {
+  const face = faces.returns;
+  if (!face || !r || typeof r !== "object" || !r.shape) return r;
+  if (r.shape.k === "never") return r;
+  if (r.conf === "opaque") return r;
+  if (litMeetsReturnConstraint(r, faces.returnsConstraint)) return r;
+  if (leqAbs(r, face).ok) return r;
+  return face;
+}
+function contractFacesFromEffectiveInterface(eff, paramNames) {
+  if (eff.source !== "handwritten") return void 0;
+  const conflictParams = eff.conflict?.params ?? [];
+  const paramFaces = [];
+  let hasFace = false;
+  for (const e of eff.params) {
+    const idx = paramNames.indexOf(e.param);
+    if (idx < 0 || conflictParams.includes(e.param)) continue;
+    paramFaces[idx] = constraintToEntryAbs(e.constraint, e.param);
+    hasFace = true;
+  }
+  let returns;
+  let returnsConstraint;
+  if (eff.returns && !eff.conflict?.returns) {
+    returns = constraintToEntryAbs(eff.returns.constraint, "return");
+    returnsConstraint = eff.returns.constraint;
+    hasFace = true;
+  }
+  return hasFace ? {
+    paramFaces,
+    ...returns !== void 0 ? { returns } : {},
+    ...returnsConstraint !== void 0 ? { returnsConstraint } : {}
+  } : void 0;
+}
+var facesByFn, contractFaceResolverSlot;
+var init_contract_face = __esm({
+  "../core/src/algebra/contract-face.ts"() {
+    "use strict";
+    init_abs();
+    init_leq();
+    init_constraint();
+    init_domain_membership();
+    init_collector_scope();
+    facesByFn = /* @__PURE__ */ new WeakMap();
+    contractFaceResolverSlot = createScopedSlot(
+      () => null
+    );
+    registerCollectorScopeParticipant(
+      (body) => contractFaceResolverSlot.runScoped(body)
+    );
+  }
+});
+
 // ../core/src/algebra/exec/calls.ts
 var calls_exports = {};
 __export(calls_exports, {
@@ -28697,12 +29726,18 @@ function evalExitCall() {
   if (evalActiveCallKeys.length > 0) evalActiveCallKeys.pop();
 }
 function $callNamed(name, fn2, args, loc, argLocs) {
-  const pureName = pureFnNameOf(fn2);
+  const faces = resolveContractFacesByName(name) ?? contractFacesOf(fn2);
   const fnObj = fn2 && (typeof fn2 === "object" || typeof fn2 === "function") ? fn2 : void 0;
-  const pk = pureName && fnObj ? callBudgetKey("pure", "", args) : void 0;
+  if (faces && fnObj) attachContractFaces(fnObj, faces);
+  const execArgs = faces ? adoptCallArgsToFaces(args, faces) : args;
+  const pureName = pureFnNameOf(fn2);
+  const pk = pureName && fnObj ? callBudgetKey("pure", "", execArgs) : void 0;
   if (fnObj && pk !== void 0) {
     const hit = pureCallMemo.get(fnObj)?.get(pk);
-    if (hit !== void 0) return routeApplyThrows(hit.abs, hit.throws);
+    if (hit !== void 0) {
+      const routed = routeApplyThrows(hit.abs, hit.throws);
+      return faces ? presentCallResultFace(routed, faces) : routed;
+    }
   }
   let result = unknown;
   let threw = false;
@@ -28736,24 +29771,24 @@ function $callNamed(name, fn2, args, loc, argLocs) {
       } else if (isHostGlobalFn(fn2)) {
         result = callHostGlobalLiteralOnly(name, fn2, args);
       } else {
-        const entered = evalEnterCall(name, fn2, args);
+        const entered = evalEnterCall(name, fn2, execArgs);
         if (!entered.ok) {
           result = evalTruncatedAbs();
         } else {
           try {
-            result = callAtFunctionBoundary(() => fn2(...args));
+            result = callAtFunctionBoundary(() => fn2(...execArgs));
           } finally {
             evalExitCall();
           }
         }
       }
     } else if (fn2 && typeof fn2 === "object" && "shape" in fn2) {
-      const entered = evalEnterCall(name, fn2, args);
+      const entered = evalEnterCall(name, fn2, execArgs);
       if (!entered.ok) {
         result = evalTruncatedAbs();
       } else {
         try {
-          result = $call(fn2, args);
+          result = $call(fn2, execArgs);
         } finally {
           evalExitCall();
         }
@@ -28787,7 +29822,7 @@ function $callNamed(name, fn2, args, loc, argLocs) {
       }
     }
   }
-  return result;
+  return faces ? presentCallResultFace(result, faces) : result;
 }
 var PURE_CALL_MEMO_MAX, pureCallMemo, evalCallCollectorSlot, evalAssignCollectorSlot, bindingSinkSlot, GLOBAL_FNS, NEVER_EXEC_HOST_FN_NAMES, hostGlobalFnIds, MAX_EVAL_CALL_DEPTH, MAX_EVAL_TOTAL_CALLS, evalCallDepth, evalTotalCalls, evalActiveCallKeys, evalBudgetSessionDepth, evalCallDepthLimit, evalTotalCallsLimit, evalFnCallIds, evalFnCallIdSeq;
 var init_calls = __esm({
@@ -28808,6 +29843,7 @@ var init_calls = __esm({
     init_objects();
     init_lru_map();
     init_collector_scope();
+    init_contract_face();
     PURE_CALL_MEMO_MAX = 256;
     pureCallMemo = /* @__PURE__ */ new WeakMap();
     evalCallCollectorSlot = createScopedSlot(() => null);
@@ -32953,9 +33989,14 @@ function $call(fn2, args, thisVal) {
 function $callInner(fn2, args, thisVal) {
   if (fn2?.shape?.k === "sum") {
     const results = fn2.shape.members.map((m) => $call(m, args, thisVal));
-    if (results.every((r) => r.shape.k === "unknown")) return unknown;
+    if (results.every((r2) => r2.shape.k === "unknown")) return unknown;
     return results.reduce((a, b) => joinAbs(a, b));
   }
+  const faces = contractFacesOf(fn2);
+  const r = $callDispatch(fn2, faces ? adoptCallArgsToFaces(args, faces) : args, thisVal);
+  return faces ? presentCallResultFace(r, faces) : r;
+}
+function $callDispatch(fn2, args, thisVal) {
   const pureName = pureFnNameOf(fn2);
   const fnObj = fn2 && typeof fn2 === "object" ? fn2 : void 0;
   const pk = pureName && fnObj ? pureMemoKey(args) : void 0;
@@ -33040,6 +34081,7 @@ var init_call = __esm({
     init_nudo_throw2();
     init_may_throw2();
     init_surface();
+    init_contract_face();
     init_state();
     init_call_budget();
     init_lru_map();
@@ -37036,539 +38078,6 @@ var init_diag_channel = __esm({
   }
 });
 
-// ../core/src/algebra/constraint.ts
-function selfTerm() {
-  return v(SELF);
-}
-function getTerm(obj2, key) {
-  return app("get", [obj2, lit(key)]);
-}
-function lenTerm(t) {
-  return app("length", [t]);
-}
-function isConstraint(x) {
-  return !!x && typeof x === "object" && x.__nudoConstraint === true;
-}
-function isNudoConstraint(x) {
-  return isConstraint(x);
-}
-function isIntFlag(c) {
-  return c.int === true || intFlaggedBuilders.has(c);
-}
-function makeBuilder(prim2, 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,
-    ...prim2 ? { prim: prim2 } : {},
-    preds: [...preds],
-    ...fields ? { fields } : {},
-    ...element ? { element } : {},
-    ...optional ? { isOptional: true } : {},
-    ...members ? { members } : {},
-    ...fnSlot ? { fn: fnSlot } : {}
-  };
-  const add2 = (p) => makeBuilder(prim2, [...preds, p], extra);
-  const builder = Object.assign(
-    /* @__PURE__ */ Object.create(null),
-    base,
-    {
-      gt: (n) => add2(gt(selfTerm(), lit(n))),
-      ge: (n) => add2(ge(selfTerm(), lit(n))),
-      lt: (n) => add2(lt(selfTerm(), lit(n))),
-      le: (n) => add2(le(selfTerm(), lit(n))),
-      int: () => makeBuilder(prim2 ?? "number", preds, { ...extra, int: true }),
-      min: (n) => add2(ge(lenTerm(selfTerm()), lit(n))),
-      max: (n) => add2(le(lenTerm(selfTerm()), lit(n))),
-      length: (n) => add2(and(ge(lenTerm(selfTerm()), lit(n)), le(lenTerm(selfTerm()), lit(n)))),
-      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 (prim2 !== void 0 && prim2 !== "number")
-          throw new Error(`nudo shift(): only numeric chains are allowed (prim=${prim2})`);
-        return makeBuilder(prim2, shiftBoundPreds(preds, n), extra);
-      },
-      optional: () => makeBuilder(prim2, 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 prim2 = typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : typeof v2 === "boolean" ? "boolean" : void 0;
-  return makeBuilder(prim2, [eq(selfTerm(), lit(v2))]);
-}
-function asNestedConstraint(x, ctx2) {
-  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: ${ctx2} 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 prim2;
-  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 (prim2 !== void 0 && prim2 !== c.prim)
-        throw new Error(`nudo and(): inconsistent prim (${prim2} vs ${c.prim})`);
-      prim2 = c.prim;
-    }
-    preds.push(...c.preds);
-    if (isIntFlag(c)) isInt = true;
-    if (!c.isOptional) allOptional = false;
-  }
-  return makeBuilder(prim2, 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, paramName2) {
-  if (t.op === "var" && t.id === SELF) return v(paramName2);
-  if (t.op === "app" && t.fn === "get" && t.args.length === 2) {
-    return getTerm(substTerm(t.args[0], paramName2), String(
-      t.args[1].op === "lit" ? t.args[1].value : ""
-    ));
-  }
-  return t;
-}
-function substPred2(p, paramName2) {
-  switch (p.op) {
-    case "gt":
-    case "ge":
-    case "lt":
-    case "le":
-    case "eq":
-    case "ne": {
-      return { op: p.op, a: substTerm(p.a, paramName2), b: substTerm(p.b, paramName2) };
-    }
-    case "typeof": {
-      return { op: "typeof", t: substTerm(p.t, paramName2), type: p.type };
-    }
-    case "and":
-      return and(...p.args.map((x) => substPred2(x, paramName2)));
-    default:
-      return p;
-  }
-}
-function instantiateConstraint(c, paramName2) {
-  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(paramName2), key);
-      parts.push(instantiateOnTerm(field.constraint, fieldTerm));
-    }
-    if (c.prim) parts.push(ptypeof(v(paramName2), 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(paramName2)))
-    );
-    const own = c.preds.map((p) => substPred2(p, paramName2));
-    return own.length === 0 ? disj : and(...own, disj);
-  }
-  if (c.fn) {
-    const own = c.preds.map((p) => substPred2(p, paramName2));
-    return own.length === 0 ? pTrue : and(...own);
-  }
-  const preds = c.preds.map((p) => substPred2(p, paramName2));
-  if (c.prim && c.preds.length === 0) {
-    return ptypeof(v(paramName2), 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 tt2 = p.t.op === "var" && p.t.id === SELF ? t : p.t;
-        return { op: "typeof", t: tt2, 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, paramName2) {
-  const t = v(paramName2);
-  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 prim2;
-  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 (prim2 === void 0) prim2 = mp;
-    else if (prim2 !== mp) return void 0;
-    values.push(v2);
-  }
-  if (prim2 === 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: prim2 }, 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 note2 = (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") note2(side.value);
-      }
-    }
-  };
-  walk(c);
-  if (any2) return "*";
-  if (out.size > 0) return [...out];
-  return void 0;
-}
-var SELF, intFlaggedBuilders, CONSTRAINT_BUILDERS, CONSTRAINT_BUILDER_NAMES, CONSTRAINT_EXPR_RE;
-var init_constraint = __esm({
-  "../core/src/algebra/constraint.ts"() {
-    "use strict";
-    init_pred();
-    init_term();
-    init_abs();
-    init_objects();
-    SELF = "__nudo_self__";
-    intFlaggedBuilders = /* @__PURE__ */ new WeakSet();
-    CONSTRAINT_BUILDERS = {
-      number,
-      string,
-      boolean,
-      any,
-      array,
-      shape,
-      lit: litC,
-      union,
-      nullable,
-      fn,
-      and: andC,
-      partial,
-      pick,
-      omit
-    };
-    CONSTRAINT_BUILDER_NAMES = Object.keys(
-      CONSTRAINT_BUILDERS
-    );
-    CONSTRAINT_EXPR_RE = new RegExp(
-      `^(${CONSTRAINT_BUILDER_NAMES.join("|")})\\s*\\(`
-    );
-  }
-});
-
 // ../core/src/algebra/refine.ts
 function diagnoseMalformedNudoImports(source) {
   for (const bad of scanMalformedNudoImports(source)) {
@@ -38979,24 +39488,28 @@ function predToChain(p) {
   }
   return `{${predToString(p)}}`;
 }
-function fmtConstraint(c) {
+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)})`;
   }
@@ -39030,7 +39543,7 @@ function interfaceTierOf(source, fnName, fromFile, opts = {}) {
 function interfaceSourceOf(source, fnName, fromFile, opts = {}) {
   return interfaceTierOf(source, fnName, fromFile, opts)?.source;
 }
-var MAX_INTERFACE_DIAGS, interfaceDiagChannel, sidecarLoadFailureSlot, MAX_SIDECAR_FP_NODES;
+var MAX_INTERFACE_DIAGS, interfaceDiagChannel, sidecarLoadFailureSlot, MAX_SIDECAR_FP_NODES, LAZY_DISPLAY_DEPTH;
 var init_interface = __esm({
   "../core/src/algebra/interface.ts"() {
     "use strict";
@@ -39054,6 +39567,7 @@ var init_interface = __esm({
     );
     registerCollectorScopeParticipant((body) => sidecarLoadFailureSlot.runScoped(body));
     MAX_SIDECAR_FP_NODES = 64;
+    LAZY_DISPLAY_DEPTH = 2;
   }
 });
 
@@ -40758,98 +41272,6 @@ var init_diagnostics = __esm({
   }
 });
 
-// ../core/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(prim2, lv) {
-  switch (prim2) {
-    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]);
-}
-var init_domain_membership = __esm({
-  "../core/src/algebra/domain-membership.ts"() {
-    "use strict";
-    init_constraint();
-  }
-});
-
 // ../core/src/algebra/postcondition.ts
 function proved() {
   return { status: "proved" };
@@ -40899,6 +41321,15 @@ function provesBarePrimDomain(arm, constraint) {
   return arm.shape.k === "prim" && arm.shape.type === constraint.prim;
 }
 function assertImplies(ret, constraint, opts) {
+  if (constraint.lazy) {
+    const seen = opts?.seen;
+    if (seen?.has(constraint.lazy)) {
+      return unprovable("lazy constraint cycle");
+    }
+    const next = seen ? new Set(seen) : /* @__PURE__ */ new Set();
+    next.add(constraint.lazy);
+    return assertImplies(ret, derefConstraint(constraint), { ...opts, seen: next });
+  }
   const phi2 = opts?.phi ?? pTrue;
   if (ret.shape.k === "never") return proved();
   if (isAnyConstraint(constraint)) return proved();
@@ -40984,7 +41415,7 @@ function assertImpliesSingle(arm, constraint, opts, phi2) {
   return assertScalar(arm, constraint, phi2);
 }
 function isAnyConstraint(c) {
-  return !c.prim && c.preds.length === 0 && !c.fields && !c.element && !c.members && !c.fn && !isIntFlag(c);
+  return !c.prim && c.preds.length === 0 && !c.fields && !c.element && !c.members && !c.fn && !c.lazy && !isIntFlag(c);
 }
 function assertShapeFields(ret, constraint, opts) {
   let slots;
@@ -43901,43 +44332,142 @@ function checkSourceInScope(filePath, source, phi2, opts) {
   resetAbsCallBudget();
   const prevTrunc = setAbsTruncationCollector((label) => truncated.add(label));
   try {
-    const report = checkSourceInner(
-      filePath,
-      source,
-      file,
-      phi2,
-      callOpts,
-      issues,
-      signatures,
-      names2,
-      truncated,
-      opts,
-      depsFp,
-      sidecarFp
+    const prevFaceResolver = setContractFaceResolver(
+      makeSameFileFaceResolver(callOpts, filePath, source, file)
     );
-    const diagIssues = sidecarDiagIssues([
-      ...takeRefineDiagsSince(refineSince),
-      ...takeInterfaceDiagsSince(ifaceSince)
-    ]);
-    if (diagIssues.length > 0) {
-      report.issues.push(...diagIssues);
-      const errors = report.issues.filter((i) => i.severity === "error").length;
-      const warnings = report.issues.filter((i) => i.severity === "warning").length;
-      const infos = report.issues.filter((i) => i.severity === "info").length;
-      report.ok = errors === 0;
-      report.summary = {
-        errors,
-        warnings,
-        infos,
-        functions: report.summary.functions
-      };
+    try {
+      attachCrossModuleContractFaces(callOpts, filePath);
+      const report = checkSourceInner(
+        filePath,
+        source,
+        file,
+        phi2,
+        callOpts,
+        issues,
+        signatures,
+        names2,
+        truncated,
+        opts,
+        depsFp,
+        sidecarFp
+      );
+      const diagIssues = sidecarDiagIssues([
+        ...takeRefineDiagsSince(refineSince),
+        ...takeInterfaceDiagsSince(ifaceSince)
+      ]);
+      if (diagIssues.length > 0) {
+        report.issues.push(...diagIssues);
+        const errors = report.issues.filter((i) => i.severity === "error").length;
+        const warnings = report.issues.filter((i) => i.severity === "warning").length;
+        const infos = report.issues.filter((i) => i.severity === "info").length;
+        report.ok = errors === 0;
+        report.summary = {
+          errors,
+          warnings,
+          infos,
+          functions: report.summary.functions
+        };
+      }
+      if (memoKey) checkMemoSet(memoKey, report, memoPaths);
+      return cloneCheckReport(report);
+    } finally {
+      setContractFaceResolver(prevFaceResolver);
     }
-    if (memoKey) checkMemoSet(memoKey, report, memoPaths);
-    return cloneCheckReport(report);
   } finally {
     setAbsTruncationCollector(prevTrunc);
   }
 }
+function makeSameFileFaceResolver(opts, filePath, source, file) {
+  const loadModule = opts.loadModule;
+  const fromFile = opts.fromFile ?? filePath;
+  const autoBind = opts.autoBind;
+  const projectDir = opts.projectDir;
+  const memo = /* @__PURE__ */ new Map();
+  return (fnName) => {
+    if (memo.has(fnName)) return memo.get(fnName);
+    let faces;
+    try {
+      const eff = effectiveInterface(source, fnName, {
+        ...loadModule ? { loadModule } : {},
+        fromFile,
+        ...autoBind !== void 0 ? { autoBind } : {},
+        ...projectDir !== void 0 ? { projectDir } : {}
+      });
+      if (eff) {
+        const params = extractFn(source, fnName, file)?.params ?? [];
+        faces = contractFacesFromEffectiveInterface(eff, params);
+      }
+    } catch {
+      faces = void 0;
+    }
+    memo.set(fnName, faces);
+    return faces;
+  };
+}
+function attachCrossModuleContractFaces(opts, filePath) {
+  const loadModule = opts.loadModule;
+  const fromFile = opts.fromFile ?? filePath;
+  if (!loadModule) return;
+  const tables2 = [];
+  for (const t of [opts.modules, opts.inject?.modules]) {
+    if (t && typeof t === "object" && !tables2.includes(t)) tables2.push(t);
+  }
+  if (tables2.length === 0) return;
+  const autoBind = opts.autoBind;
+  const projectDir = opts.projectDir;
+  const facesCache = /* @__PURE__ */ new Map();
+  const facesFor = (depSource, depPath, name, paramNames) => {
+    const key = `${depPath}\0${name}`;
+    if (facesCache.has(key)) return facesCache.get(key);
+    let faces;
+    try {
+      const eff = effectiveInterface(depSource, name, {
+        loadModule,
+        fromFile: depPath,
+        ...autoBind !== void 0 ? { autoBind } : {},
+        ...projectDir !== void 0 ? { projectDir } : {}
+      });
+      if (eff) faces = contractFacesFromEffectiveInterface(eff, paramNames);
+    } catch {
+      faces = void 0;
+    }
+    facesCache.set(key, faces);
+    return faces;
+  };
+  const attachFnAbs = (v2, depSource, depPath, name) => {
+    if (!v2 || typeof v2 !== "object" || !("shape" in v2)) return;
+    const shape2 = v2.shape;
+    if (shape2.k !== "fn") return;
+    let paramNames;
+    try {
+      paramNames = extractFn(depSource, name)?.params ?? [];
+    } catch {
+      paramNames = [];
+    }
+    const faces = facesFor(depSource, depPath, name, paramNames);
+    if (faces) attachContractFaces(v2, faces);
+  };
+  for (const table of tables2) {
+    for (const [spec, mod2] of Object.entries(table)) {
+      if (!mod2 || typeof mod2 !== "object") continue;
+      const named = mod2.named;
+      if (!named) continue;
+      let depSource;
+      try {
+        depSource = loadModule(spec, fromFile);
+      } catch {
+        depSource = void 0;
+      }
+      if (!depSource) continue;
+      const depPath = resolveDepPath(fromFile, spec);
+      for (const [name, v2] of Object.entries(named)) {
+        attachFnAbs(v2, depSource, depPath, name);
+      }
+      const def = mod2.default;
+      if (def !== void 0) attachFnAbs(def, depSource, depPath, "default");
+    }
+  }
+}
 function sidecarDiagIssues(diags) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -44445,6 +44975,8 @@ var init_check = __esm({
     init_constraint();
     init_postcondition();
     init_generalize();
+    init_contract_face();
+    init_sidecar_path();
     init_param_surface();
     init_fn_fp();
     init_stable_source_key();
@@ -45026,6 +45558,7 @@ __export(src_exports, {
   currentExecPhi: () => currentExecPhi,
   currentPhi: () => currentPhi,
   definitelyNotNullishShape: () => definitelyNotNullishShape,
+  derefConstraint: () => derefConstraint,
   describePhi: () => describePhi,
   div: () => div,
   drainPromiseMicros: () => drainPromiseMicros,
@@ -45149,6 +45682,7 @@ __export(src_exports, {
   joinObjects: () => joinObjects,
   joinThenProject: () => joinThenProject,
   joinValues: () => joinValues,
+  lazy: () => lazy,
   le: () => le,
   leNum: () => leNum,
   leavePromiseExecutorScope: () => leavePromiseExecutorScope,
@@ -60210,7 +60744,7 @@ var require_typescript = __commonJS({
         affectsEmitOptionDeclarations: () => affectsEmitOptionDeclarations,
         allKeysStartWithDot: () => allKeysStartWithDot,
         altDirectorySeparator: () => altDirectorySeparator,
-        and: () => and7,
+        and: () => and8,
         append: () => append,
         appendIfUnique: () => appendIfUnique,
         arrayFrom: () => arrayFrom,
@@ -63665,7 +64199,7 @@ var require_typescript = __commonJS({
       function isPatternMatch({ prefix: prefix2, suffix }, candidate) {
         return candidate.length >= prefix2.length + suffix.length && startsWith(candidate, prefix2) && endsWith(candidate, suffix);
       }
-      function and7(f, g) {
+      function and8(f, g) {
         return (arg) => f(arg) && g(arg);
       }
       function or2(...fs) {
@@ -114751,7 +115285,7 @@ ${lanes.join("\n")}
         SignatureCheckMode3[SignatureCheckMode3["Callback"] = 3] = "Callback";
         return SignatureCheckMode3;
       })(SignatureCheckMode || {});
-      var isNotOverloadAndNotAccessor = and7(isNotOverload, isNotAccessor);
+      var isNotOverloadAndNotAccessor = and8(isNotOverload, isNotAccessor);
       var intrinsicTypeKinds = new Map(Object.entries({
         Uppercase: 0,
         Lowercase: 1,
@@ -157737,7 +158271,7 @@ ${lanes.join("\n")}
                 if (flags & (1920 | 384)) {
                   return;
                 }
-                const exportedDeclarationsCount = countWhere(declarations, and7(isNotOverloadAndNotAccessor, not2(isInterfaceDeclaration)));
+                const exportedDeclarationsCount = countWhere(declarations, and8(isNotOverloadAndNotAccessor, not2(isInterfaceDeclaration)));
                 if (flags & 524288 && exportedDeclarationsCount <= 2) {
                   return;
                 }
@@ -229094,7 +229628,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const maybeHeritageClauseSymbol = getHeritageClauseSymbolTable(classDeclaration, checker);
         const implementedType = checker.getTypeAtLocation(implementedTypeNode);
         const implementedTypeSymbols = checker.getPropertiesOfType(implementedType);
-        const nonPrivateAndNotExistedInHeritageClauseMembers = implementedTypeSymbols.filter(and7(symbolPointsToNonPrivateMember, (symbol) => !maybeHeritageClauseSymbol.has(symbol.escapedName)));
+        const nonPrivateAndNotExistedInHeritageClauseMembers = implementedTypeSymbols.filter(and8(symbolPointsToNonPrivateMember, (symbol) => !maybeHeritageClauseSymbol.has(symbol.escapedName)));
         const classType = checker.getTypeAtLocation(classDeclaration);
         const constructor = find2(classDeclaration.members, (m) => isConstructorDeclaration(m));
         if (!classType.getNumberIndexType()) {
@@ -256467,7 +257001,7 @@ ${options.prefix}` : "\n" : options.prefix
         affectsEmitOptionDeclarations: () => affectsEmitOptionDeclarations,
         allKeysStartWithDot: () => allKeysStartWithDot,
         altDirectorySeparator: () => altDirectorySeparator,
-        and: () => and7,
+        and: () => and8,
         append: () => append,
         appendIfUnique: () => appendIfUnique,
         arrayFrom: () => arrayFrom,
@@ -288176,7 +288710,7 @@ function runTscBaseline(root, files) {
   }
 }
 async function migrateVerify(paths, opts = {}) {
-  const { checkSource: checkSource2, formatCheckReport: formatCheckReport2, pTrue: pTrue3 } = await Promise.resolve().then(() => (init_src(), src_exports));
+  const { checkSource: checkSource2, formatCheckReport: formatCheckReport2, pTrue: pTrue4 } = await Promise.resolve().then(() => (init_src(), src_exports));
   const { collectSkipReturns: collectSkipReturns2, defaultLoadModule: defaultLoadModule3, findProjectConfig: findProjectConfig3, interfaceConfig: interfaceConfig3, checkConfig: checkConfig2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
   const files = [];
   for (const p of paths) {
@@ -288201,7 +288735,7 @@ async function migrateVerify(paths, opts = {}) {
     const proj = findProjectConfig3(dirname29(file));
     const cCfg = checkConfig2(proj?.config);
     const autoBind = interfaceConfig3(proj?.config).autoBind;
-    const report = checkSource2(file, source, pTrue3, {
+    const report = checkSource2(file, source, pTrue4, {
       loadModule: defaultLoadModule3,
       fromFile: file,
       ...autoBind === false ? { autoBind: false } : {},
@@ -290630,7 +291164,7 @@ async function healthFile(filePath, records) {
   return report;
 }
 async function countInterfaceDrift(filePath) {
-  const { sidecarPathOf: sidecarPathOf2, checkSource: checkSource2, pTrue: pTrue3 } = await Promise.resolve().then(() => (init_src(), src_exports));
+  const { sidecarPathOf: sidecarPathOf2, checkSource: checkSource2, pTrue: pTrue4 } = await Promise.resolve().then(() => (init_src(), src_exports));
   const { defaultLoadModule: defaultLoadModule3 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
   const { existsSync: ex, readFileSync: rf } = await import("fs");
   const abs2 = resolve18(filePath);
@@ -290648,7 +291182,7 @@ async function countInterfaceDrift(filePath) {
     const proj = findProjectConfig3(dirname28(abs2));
     const autoBind = interfaceConfig3(proj?.config).autoBind;
     const source = rf(abs2, "utf-8");
-    const r = checkSource2(abs2, source, pTrue3, {
+    const r = checkSource2(abs2, source, pTrue4, {
       loadModule: defaultLoadModule3,
       fromFile: abs2,
       ...autoBind === false ? { autoBind: false } : {},