@nudojs/core 1.7.10 → 1.8.0

package/dist/{chunk-MJP4P5J3.js → chunk-P6O5BXOA.js}

@@ -12,7 +12,7 @@ var lit = (value) => ({
   value
 });
 var v = (id) => ({ op: "var", id });
-var app = (fn, args) => ({ op: "app", fn, args });
+var app = (fn2, args) => ({ op: "app", fn: fn2, args });
 function termEquals(a, b) {
   if (a === b) return true;
   if (a.op !== b.op) return false;
@@ -60,13 +60,13 @@ function termToString(t) {
 function simplifyTerm(t) {
   if (t.op !== "app") return t;
   const args = t.args.map(simplifyTerm);
-  const fn = t.fn;
+  const fn2 = t.fn;
   if (args.every((a) => a.op === "lit")) {
     const xs = args.map((a) => a.value);
-    const folded = foldLiterals(fn, xs);
+    const folded = foldLiterals(fn2, xs);
     if (folded !== void 0) return lit(folded);
   }
-  if (fn === "*" && args.length === 2) {
+  if (fn2 === "*" && args.length === 2) {
     const [a, b] = args;
     const one = (t2) => t2.op === "lit" && t2.value === 1;
     const surviveMulOne = (t2) => {
@@ -76,36 +76,36 @@ function simplifyTerm(t) {
       if (typeof v2 === "boolean") return lit(v2 ? 1 : 0);
       if (v2 === null) return lit(0);
       if (typeof v2 === "string") return lit(Number(v2));
-      if (typeof v2 === "bigint") return app(fn, args);
+      if (typeof v2 === "bigint") return app(fn2, args);
       return lit(NaN);
     };
     if (one(b)) return surviveMulOne(a);
     if (one(a)) return surviveMulOne(b);
   }
-  if (fn === "-" && args.length === 2) {
+  if (fn2 === "-" && args.length === 2) {
     const [a, b] = args;
     if (b.op === "lit" && Object.is(b.value, 0)) return a;
   }
-  return app(fn, args);
+  return app(fn2, args);
 }
-function foldLiterals(fn, xs) {
-  if (fn === "+" && xs.length === 2) {
+function foldLiterals(fn2, xs) {
+  if (fn2 === "+" && xs.length === 2) {
     const [a, b] = xs;
     if (typeof a === "number" && typeof b === "number") return a + b;
     if (typeof a === "string" || typeof b === "string") return String(a) + String(b);
     return void 0;
   }
-  if (fn === "-" && xs.length === 2) {
+  if (fn2 === "-" && xs.length === 2) {
     const [a, b] = xs;
     if (typeof a === "number" && typeof b === "number") return a - b;
     return void 0;
   }
-  if (fn === "*" && xs.length === 2) {
+  if (fn2 === "*" && xs.length === 2) {
     const [a, b] = xs;
     if (typeof a === "number" && typeof b === "number") return a * b;
     return void 0;
   }
-  if (fn === "neg" && xs.length === 1) {
+  if (fn2 === "neg" && xs.length === 1) {
     const a = xs[0];
     if (typeof a === "number") return -a;
     return void 0;
@@ -378,8 +378,8 @@ var implicationOracleSlot = createScopedSlot(
   () => void 0
 );
 registerCollectorScopeParticipant((body) => implicationOracleSlot.runScoped(body));
-function setImplicationOracle(fn) {
-  implicationOracleSlot.set(fn);
+function setImplicationOracle(fn2) {
+  implicationOracleSlot.set(fn2);
 }
 function getImplicationOracle() {
   return implicationOracleSlot.get();
@@ -1172,9 +1172,9 @@ function shapeOfTerm(t) {
   }
   return { k: "unknown" };
 }
-function abs(shape, term, pred, conf) {
+function abs(shape2, term, pred, conf) {
   return {
-    shape,
+    shape: shape2,
     term,
     pred: pred && pred.op !== "true" ? pred : void 0,
     conf
@@ -1455,11 +1455,11 @@ function markPureFn(target, name) {
   const impl = implByAbs.get(target);
   if (impl) impl.pureName = name;
 }
-function pureFnNameOf(fn) {
-  if (!fn || typeof fn !== "object" && typeof fn !== "function") return void 0;
-  const impl = implByAbs.get(fn);
+function pureFnNameOf(fn2) {
+  if (!fn2 || typeof fn2 !== "object" && typeof fn2 !== "function") return void 0;
+  const impl = implByAbs.get(fn2);
   if (impl?.pureName) return impl.pureName;
-  return fn._memoize;
+  return fn2._memoize;
 }
 function absFunction(params, impl, opts) {
   const a = {
@@ -1608,8 +1608,8 @@ var derivationSlot = createScopedSlot(() => ({
 }));
 registerCollectorScopeParticipant((body) => derivationSlot.runScoped(body));
 var byAbs = /* @__PURE__ */ new WeakMap();
-function setDerivationCollector(fn) {
-  derivationSlot.get().collector = fn;
+function setDerivationCollector(fn2) {
+  derivationSlot.get().collector = fn2;
 }
 function hasDerivationSession() {
   return derivationSlot.get().sessionNodes !== null;
@@ -1764,10 +1764,10 @@ function propertyKeyOf(a) {
   return String(v2);
 }
 function objOf(slots, opts) {
-  const shape = { k: "obj", slots };
-  if (opts?.index) shape.index = opts.index;
-  if (opts?.open) shape.open = true;
-  return { shape, conf: "exact" };
+  const shape2 = { k: "obj", slots };
+  if (opts?.index) shape2.index = opts.index;
+  if (opts?.open) shape2.open = true;
+  return { shape: shape2, conf: "exact" };
 }
 function isObj(a) {
   return a.shape.k === "obj";
@@ -1819,9 +1819,9 @@ function spread(base, over) {
     if (indexSlots && isObj(base)) {
       const slots2 = { ...base.shape.slots };
       for (const [k, s] of Object.entries(indexSlots)) setSlot(slots2, k, s);
-      const shape2 = { k: "obj", slots: slots2 };
-      if (base.shape.open) shape2.open = true;
-      return { shape: shape2, conf: confJoin(base.conf, over.conf) };
+      const shape3 = { k: "obj", slots: slots2 };
+      if (base.shape.open) shape3.open = true;
+      return { shape: shape3, conf: confJoin(base.conf, over.conf) };
     }
     if (!isObj(base)) return unknown;
     return {
@@ -1837,12 +1837,12 @@ function spread(base, over) {
     setSlot(slots, k, s);
   }
   const open = base.shape.open || over.shape.open || false;
-  const shape = { k: "obj", slots };
-  if (open) shape.open = true;
+  const shape2 = { k: "obj", slots };
+  if (open) shape2.open = true;
   if (base.shape.index || over.shape.index) {
-    shape.index = over.shape.index ?? base.shape.index;
+    shape2.index = over.shape.index ?? base.shape.index;
   }
-  return { shape, conf: confJoin(base.conf, over.conf) };
+  return { shape: shape2, conf: confJoin(base.conf, over.conf) };
 }
 function spreadIndexSlots(over) {
   const s = over.shape;
@@ -2006,9 +2006,9 @@ function absShapeKey(a, seen = /* @__PURE__ */ new Set()) {
   }
 }
 function fnOf(params, name) {
-  const shape = { k: "fn", params };
-  if (name) shape.name = name;
-  return { shape, conf: "exact" };
+  const shape2 = { k: "fn", params };
+  if (name) shape2.name = name;
+  return { shape: shape2, conf: "exact" };
 }
 function joinFunctions(a, b) {
   const sa = a.shape;
@@ -2487,7 +2487,7 @@ function tryPromoteHofCallback(env, cevalName, method, argAbses, loc) {
   return env.vars.get(cevalName);
 }
 function snapshotAbs(a) {
-  const shape = a.shape;
+  const shape2 = a.shape;
   const copyShape = (s) => {
     switch (s.k) {
       case "arr":
@@ -2542,7 +2542,7 @@ function snapshotAbs(a) {
     }
   };
   return {
-    shape: copyShape(shape),
+    shape: copyShape(shape2),
     term: a.term,
     pred: a.pred,
     conf: a.conf
@@ -2657,17 +2657,17 @@ function mapHasShapeOnlyVar(p, map) {
 function substPredAbs(p, map) {
   if (!predUsesMappedVars(p, map)) return { pred: p, dropped: false };
   if (mapHasShapeOnlyVar(p, map)) return { pred: pTrue, dropped: true };
-  const substTerm = (t) => {
+  const substTerm2 = (t) => {
     if (t.op === "var") {
       const arg = map.get(t.id);
       return arg?.term ?? t;
     }
     if (t.op === "app") {
-      return { op: "app", fn: t.fn, args: t.args.map(substTerm) };
+      return { op: "app", fn: t.fn, args: t.args.map(substTerm2) };
     }
     return t;
   };
-  const replaced = substPred(p, substTerm);
+  const replaced = substPred(p, substTerm2);
   const fold = (q) => {
     switch (q.op) {
       case "true":
@@ -2807,7 +2807,7 @@ function substAbsInner(a, map, cache, visiting) {
   if (hit !== void 0) return hit;
   if (visiting.has(a)) return a;
   visiting.add(a);
-  const shape = substShape(a.shape, map, cache, visiting);
+  const shape2 = substShape(a.shape, map, cache, visiting);
   const term = a.term ? substTermAbs(a.term, map) : void 0;
   let pred = a.pred;
   let conf = a.conf;
@@ -2817,7 +2817,7 @@ function substAbsInner(a, map, cache, visiting) {
     if (r.dropped) conf = confJoin(conf, "partial");
   }
   visiting.delete(a);
-  const result = abs(shape, term, pred, conf);
+  const result = abs(shape2, term, pred, conf);
   cache.set(a, result);
   return result;
 }
@@ -2872,13 +2872,13 @@ function bindTypeVars(pattern, arg, map, depth = 0) {
     return;
   }
 }
-function instantiateReturn(fn, args) {
-  const shape = fn.shape;
-  if (!shape || shape.k !== "fn") return unknown;
-  const impl = getFnImpl(fn);
+function instantiateReturn(fn2, args) {
+  const shape2 = fn2.shape;
+  if (!shape2 || shape2.k !== "fn") return unknown;
+  const impl = getFnImpl(fn2);
   const src = impl?.relation ?? {
-    paramTypes: shape.paramTypes ?? [],
-    returnType: shape.returnType ?? unknown
+    paramTypes: shape2.paramTypes ?? [],
+    returnType: shape2.returnType ?? unknown
   };
   const map = /* @__PURE__ */ new Map();
   src.paramTypes.forEach((p, i) => {
@@ -2897,16 +2897,16 @@ function instantiateReturn(fn, args) {
   return substAbs(src.returnType, map);
 }
 var applyCallbackHost;
-function setApplyCallbackHost(fn) {
-  applyCallbackHost = fn;
+function setApplyCallbackHost(fn2) {
+  applyCallbackHost = fn2;
 }
-function applyCallbackValue(fn, args, env, phi2, budget) {
-  if (typeof fn === "function") {
-    const r = fn(...args);
+function applyCallbackValue(fn2, args, env, phi2, budget) {
+  if (typeof fn2 === "function") {
+    const r = fn2(...args);
     if (r && typeof r === "object" && "shape" in r) return r;
     return unknown;
   }
-  const absFn = asAbs(fn);
+  const absFn = asAbs(fn2);
   if (absFn) return applyCallbackAbs(absFn, args, env, phi2, budget);
   return unknown;
 }
@@ -4411,8 +4411,8 @@ function str2(conf = "path") {
 function boolPrim(conf = "partial") {
   return abs({ k: "prim", type: "boolean" }, void 0, void 0, conf);
 }
-function peelBrand(shape) {
-  let s = shape;
+function peelBrand(shape2) {
+  let s = shape2;
   while (s.k === "brand") s = s.shape.shape;
   return s;
 }
@@ -5792,8 +5792,8 @@ function matchAsOverride(stmt, opts) {
   }
   return null;
 }
-function fnBodyHasThis(fn) {
-  const body = fn.body;
+function fnBodyHasThis(fn2) {
+  const body = fn2.body;
   if (!body) return false;
   const seen = /* @__PURE__ */ new Set();
   const walk = (n) => {
@@ -5817,8 +5817,8 @@ function fnBodyHasThis(fn) {
   };
   return walk(body);
 }
-function fnBodyHasOwnArguments(fn) {
-  const body = fn.body;
+function fnBodyHasOwnArguments(fn2) {
+  const body = fn2.body;
   if (!body) return false;
   const seen = /* @__PURE__ */ new Set();
   const walk = (n) => {
@@ -6343,16 +6343,16 @@ function isExpression(n) {
 
 // src/algebra/exec/transpile/transpile-dispatch.ts
 var dispatch = {};
-function bindTranspileExpression(fn) {
-  dispatch.expr = fn;
+function bindTranspileExpression(fn2) {
+  dispatch.expr = fn2;
 }
-function bindTranspileShortCircuit(fn) {
-  dispatch.shortCircuit = fn;
+function bindTranspileShortCircuit(fn2) {
+  dispatch.shortCircuit = fn2;
 }
 function emitTranspileExpression(expr, opts = {}) {
-  const fn = dispatch.expr;
-  if (!fn) throw new Error("transpileExpression not bound (expr.ts not loaded)");
-  return fn(expr, opts);
+  const fn2 = dispatch.expr;
+  if (!fn2) throw new Error("transpileExpression not bound (expr.ts not loaded)");
+  return fn2(expr, opts);
 }
 
 // src/algebra/exec/transpile/member-path.ts
@@ -6547,7 +6547,7 @@ function emitArrMutatorRebinds(expr, opts, pad) {
     }
     if (node.type === "UpdateExpression" && node.argument) {
       const arg = node.argument;
-      const fn = node.operator === "++" ? "$updateAdd" : "$updateSub";
+      const fn2 = node.operator === "++" ? "$updateAdd" : "$updateSub";
       if (arg.type === "MemberExpression") {
         const path = memberPathOf(
           arg,
@@ -6555,7 +6555,7 @@ function emitArrMutatorRebinds(expr, opts, pad) {
         );
         if (path) {
           const readSrc = readPathSrc(path);
-          lines.push(`${pad}${path.rootSrc} = ${setPathSrc(path, `${fn}(${readSrc})`)};`);
+          lines.push(`${pad}${path.rootSrc} = ${setPathSrc(path, `${fn2}(${readSrc})`)};`);
         }
       }
     }
@@ -6987,6 +6987,13 @@ var memberGuardTarget = (n) => {
   if (key === void 0) return void 0;
   return { name: m.object.name, key };
 };
+var 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;
+};
 function nullishGuardOf(test) {
   const t = test;
   if (t?.type === "LogicalExpression") return compositeNullishGuardOf(t);
@@ -6996,12 +7003,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;
@@ -7033,6 +7044,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) {
@@ -7053,6 +7078,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;
@@ -7074,11 +7124,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 names = forkBindingNames instanceof Set ? forkBindingNames : new Set(forkBindingNames);
-  if (names.has(guard.name)) return thunk;
-  return `((${guard.name}) => ${thunk})(${nullishRemoveCallOf(guard)})`;
+  if (matching.some((g) => names.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;
@@ -7181,12 +7235,12 @@ 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(
+      narrowNullishArmThunks(
         transpileBlockAsThunk(stmt.consequent, depth, scopedOpts),
-        earlyGuard,
+        earlyGuards,
         "cons",
         recvSet
       ),
@@ -7200,7 +7254,7 @@ function transpileFnBodyStmts(stmtsIn, depth, opts, varScope) {
 ${altBody}
 ${pad}}`;
     const altNarrowed = narrowTypeArmThunk(
-      narrowNullishArmThunk(altThunk, earlyGuard, "alt", recvSet),
+      narrowNullishArmThunks(altThunk, earlyGuards, "alt", recvSet),
       earlyTGuard,
       "alt",
       recvSet
@@ -7530,16 +7584,16 @@ ${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),
+        narrowNullishArmThunks(consRaw, guards, "cons", recvSet),
         tguard,
         "cons",
         recvSet
       );
       const altNarrowed = altRaw === null ? null : narrowTypeArmThunk(
-        narrowNullishArmThunk(altRaw, guard, "alt", recvSet),
+        narrowNullishArmThunks(altRaw, guards, "alt", recvSet),
         tguard,
         "alt",
         recvSet
@@ -7987,13 +8041,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 names = [...assigned].filter((n) => !HOST_INTRINSIC_SET.has(n) && !bodyLocalDecls.has(n));
       const loopOpts = opts.loopLabel ? `label: ${JSON.stringify(opts.loopLabel)}` : "";
       if (names.length === 0) {
         return [
           `${pad}// while \u2192 $whileSeq (bounded, max=${max})`,
           `${pad}$whileSeq(() => ${test}, () => {`,
-          body,
+          bodyNarrowed,
           `${pad}}, ${max}${loopOpts ? `, { ${loopOpts} }` : ""});`
         ].join("\n");
       }
@@ -8002,7 +8067,7 @@ ${indent(depth + 1)}]${dflt})`;
       return [
         `${pad}// while \u2192 $whileSeq (instrumented bindings: ${names.join(", ")})`,
         `${pad}$whileSeq(() => ${test}, () => {`,
-        body,
+        bodyNarrowed,
         `${pad}}, ${max}, { pack: () => ${packSrc}, unpack: ${unpackSrc}${loopOpts ? `, ${loopOpts}` : ""} });`
       ].join("\n");
     }
@@ -8021,6 +8086,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 names = [...assigned].filter((n) => !HOST_INTRINSIC_SET.has(n) && !bodyLocalDecls.has(n));
       const packSrc = names.length === 0 ? null : `$obj({ ${names.map((n) => `${JSON.stringify(n)}: $copy(${n})`).join(", ")} })`;
       const unpackSrc = names.length === 0 ? null : `(__lp) => { ${names.map((n) => `${n} = $get(__lp, ${JSON.stringify(n)});`).join(" ")} }`;
@@ -8031,7 +8107,7 @@ ${indent(depth + 1)}]${dflt})`;
         `{`,
         bodyStmts,
         `${indent(depth + 1)}$whileSeq(() => ${test}, () => {`,
-        bodyStmts,
+        innerBody,
         `${indent(depth + 1)}}, ${max}${optsSrc});`,
         `${pad}}`
       ].join("\n");
@@ -8437,13 +8513,15 @@ 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}))`;
@@ -8455,9 +8533,9 @@ function transpileShortCircuitExpr(opts, parts) {
   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_", names), guard, "cons", names);
-  const altFinal = narrowNullishArmThunk(forkArmThunk(altLines, "fk2_", names), guard, "alt", names);
+  const guards = parts.narrowGuards;
+  const consFinal = narrowNullishArmThunks(forkArmThunk(consLines, "fk1_", names), guards, "cons", names);
+  const altFinal = narrowNullishArmThunks(forkArmThunk(altLines, "fk2_", names), guards, "alt", names);
   return [
     `(() => {`,
     `  const __test = (${parts.alwaysSrc});`,
@@ -8679,7 +8757,7 @@ ${inner}
           testSrc: `$nullishTest(${l})`
         });
       }
-      const andGuard = nullishGuardOf(expr.left);
+      const leftGuards = nullishGuardsOf(expr.left);
       const andTypeGuard = typeGuardOf(expr.left);
       return op === "&&" ? transpileShortCircuitExpr(opts, {
         alwaysNodes: [lNode],
@@ -8688,7 +8766,7 @@ ${inner}
         consNodes: [rNode],
         altSrc: "__test",
         altNodes: [],
-        narrowGuard: andGuard?.arm === "cons" ? andGuard : void 0,
+        narrowGuards: leftGuards.filter((g) => g.arm === "cons"),
         typeGuard: andTypeGuard
       }) : transpileShortCircuitExpr(opts, {
         alwaysNodes: [lNode],
@@ -8697,7 +8775,7 @@ ${inner}
         consNodes: [],
         altSrc: r,
         altNodes: [rNode],
-        narrowGuard: andGuard?.arm === "alt" ? andGuard : void 0,
+        narrowGuards: leftGuards.filter((g) => g.arm === "alt"),
         typeGuard: andTypeGuard
       });
     }
@@ -8716,8 +8794,9 @@ ${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),
+        // Bug 23：`typeof v === "string" ? v + "!" : 0`；#118 v3/#120：多名复合
+        // `obj == null || node.p == null ? … : node.p.name` 一臂多事实）
+        narrowGuards: nullishGuardsOf(expr.test),
         typeGuard: typeGuardOf(expr.test)
       });
     }
@@ -8733,8 +8812,8 @@ ${inner}
         const r2 = isExpression(expr.right) ? transpileExpression(expr.right, opts) : "$lit(void 0)";
         return `$instanceofNonIdent(${l2}, ${r2})`;
       }
-      const fn = BIN_OPS[expr.operator];
-      if (!fn) {
+      const fn2 = BIN_OPS[expr.operator];
+      if (!fn2) {
         throw new NudoUnsupportedError(
           `binary:${expr.operator}`,
           expr.loc ? { line: expr.loc.start.line, column: expr.loc.start.column } : void 0
@@ -8742,7 +8821,7 @@ ${inner}
       }
       const l = isExpression(expr.left) ? transpileExpression(expr.left, opts) : "$lit(void 0)";
       const r = isExpression(expr.right) ? transpileExpression(expr.right, opts) : "$lit(void 0)";
-      return `${fn}(${l}, ${r})`;
+      return `${fn2}(${l}, ${r})`;
     }
     case "UnaryExpression": {
       if (expr.operator === "delete") {
@@ -8778,20 +8857,20 @@ ${inner}
     }
     case "UpdateExpression": {
       const arg = expr.argument;
-      const fn = expr.operator === "++" ? "$updateAdd" : "$updateSub";
+      const fn2 = expr.operator === "++" ? "$updateAdd" : "$updateSub";
       if (arg.type === "Identifier") {
         if (isConstAssignTarget(arg.name, opts)) {
           return `$throwConstAssign()`;
         }
-        if (expr.prefix) return `${arg.name} = ${fn}(${arg.name})`;
-        return `((__old) => (${arg.name} = ${fn}(__old), __old))($toNumeric(${arg.name}))`;
+        if (expr.prefix) return `${arg.name} = ${fn2}(${arg.name})`;
+        return `((__old) => (${arg.name} = ${fn2}(__old), __old))($toNumeric(${arg.name}))`;
       }
       if (arg.type === "MemberExpression") {
         const m = arg;
         const path = memberPathOf(m, opts);
         if (path) {
           const readSrc = readPathSrc(path);
-          if (expr.prefix) return `${fn}(${readSrc})`;
+          if (expr.prefix) return `${fn2}(${readSrc})`;
           return `$toNumeric(${readSrc})`;
         }
       }
@@ -8971,23 +9050,23 @@ ${mBodyInner}
           continue;
         }
         if (prop.value.type === "FunctionExpression" && !prop.value.async) {
-          const fn = prop.value;
-          if (!fn.generator) {
-            const displayNames = paramDisplayNames(fn.params);
-            const bindNames = methodBindNames(fn.params);
-            const mHasArgs = fnBodyHasOwnArguments({ body: fn.body });
+          const fn2 = prop.value;
+          if (!fn2.generator) {
+            const displayNames = paramDisplayNames(fn2.params);
+            const bindNames = methodBindNames(fn2.params);
+            const mHasArgs = fnBodyHasOwnArguments({ body: fn2.body });
             const methodOpts = {
               ...opts,
               inLoop: 0,
               thisParam: "__this",
               argsBinding: mHasArgs ? "__nudoArgs" : void 0
             };
-            let mBodyInner = emitFnBlockBody(fn.body, 1, methodOpts, {
-              varParams: paramNamesOfFn(fn.params)
+            let mBodyInner = emitFnBlockBody(fn2.body, 1, methodOpts, {
+              varParams: paramNamesOfFn(fn2.params)
             });
             let mParams = ["__this", ...bindNames];
             if (mHasArgs) {
-              const bound = emitParamBindingFromArgs(fn.params, "  ", methodOpts, "__nudoArgs");
+              const bound = emitParamBindingFromArgs(fn2.params, "  ", methodOpts, "__nudoArgs");
               mBodyInner = [
                 `  let __nudoArgs = $arguments(__margs);`,
                 ...bound.prologue,
@@ -9329,14 +9408,14 @@ ${mBodyInner}
     }
     case "ArrowFunctionExpression":
     case "FunctionExpression": {
-      const fn = expr;
+      const fn2 = expr;
       const isArrow = expr.type === "ArrowFunctionExpression";
-      const nfeName = !isArrow && fn.id?.name ? fn.id.name : null;
+      const nfeName = !isArrow && fn2.id?.name ? fn2.id.name : null;
       const fnValSrc = (() => {
-        const fnCtor = isArrow || !!fn.async || !!fn.generator ? false : true;
-        const hasThis = !isArrow && fnBodyHasThis(fn);
-        const hasArgs = !isArrow && fnBodyHasOwnArguments(fn);
-        const { sig, rest, prologue } = emitParamBinding(fn.params, indent(1), opts);
+        const fnCtor = isArrow || !!fn2.async || !!fn2.generator ? false : true;
+        const hasThis = !isArrow && fnBodyHasThis(fn2);
+        const hasArgs = !isArrow && fnBodyHasOwnArguments(fn2);
+        const { sig, rest, prologue } = emitParamBinding(fn2.params, indent(1), opts);
         const fnBodyOpts = {
           ...opts,
           inLoop: 0,
@@ -9348,12 +9427,12 @@ ${mBodyInner}
         const restRaw = rest && !useArgsSlot ? `__rest_raw` : rest;
         const restPrologue = rest && !useArgsSlot && restRaw ? [`  const ${rest} = $arr(${restRaw});`] : [];
         const paramParts = restRaw ? [...sig, `...${restRaw}`] : sig;
-        const nameList = `[${paramDisplayNames(fn.params).map((p) => JSON.stringify(p)).join(", ")}]`;
+        const nameList = `[${paramDisplayNames(fn2.params).map((p) => JSON.stringify(p)).join(", ")}]`;
         const thisPrologue = hasThis ? [`let __this = $rawThis(this);`] : [];
         let argsSlotPrologue = [];
         let argsParamParts = paramParts;
         if (useArgsSlot) {
-          const bound = emitParamBindingFromArgs(fn.params, "  ", fnBodyOpts, "__nudoArgs");
+          const bound = emitParamBindingFromArgs(fn2.params, "  ", fnBodyOpts, "__nudoArgs");
           argsSlotPrologue = [`  let __nudoArgs = $arguments(__allArgs);`, ...bound.prologue];
           argsParamParts = ["...__allArgs"];
         } else if (hasArgs && hasThis) {
@@ -9370,27 +9449,27 @@ ${mBodyInner}
           ...thisPrologue,
           ...argsSlotPrologue
         ];
-        if (fn.body.type === "BlockStatement") {
+        if (fn2.body.type === "BlockStatement") {
           const raw = withImplicitReturn(
-            fn.body,
-            [...allPrologue, transpileFnBodyStmts(fn.body.body, 1, fnBodyOpts, {
+            fn2.body,
+            [...allPrologue, transpileFnBodyStmts(fn2.body.body, 1, fnBodyOpts, {
               // Bug 21：函数体 var 提升边界——参数模式名已绑定，不得提升
-              skip: paramNamesOfFn(fn.params)
+              skip: paramNamesOfFn(fn2.params)
             })].join("\n"),
             1
           );
-          const inner = fn.generator ? `return $gen(() => {
+          const inner = fn2.generator ? `return $gen(() => {
 ${raw}
 });` : raw;
           if (hasThis) {
-            const wrap = fn.async && !fn.generator ? `function (${argsParamParts.join(", ")}) { return $async(() => {
+            const wrap = fn2.async && !fn2.generator ? `function (${argsParamParts.join(", ")}) { return $async(() => {
 ${inner}
 }); }` : `function (${argsParamParts.join(", ")}) {
 ${inner}
 }`;
             return `$fnVal(${nameList}, ${wrap}, { ctor: ${fnCtor}${hasArgs ? ", padArgs: false" : ""} })`;
           }
-          if (fn.async && !fn.generator) {
+          if (fn2.async && !fn2.generator) {
             return `$fnVal(${nameList}, (${argsParamParts.join(", ")}) => $async(() => {
 ${inner}
 }), { ctor: ${fnCtor} })`;
@@ -9399,13 +9478,13 @@ ${inner}
 ${inner}
 }, { ctor: ${fnCtor} })`;
         }
-        const bodySrc = transpileExpression(fn.body, fnBodyOpts);
+        const bodySrc = transpileExpression(fn2.body, fnBodyOpts);
         if (allPrologue.length > 0 || hasThis) {
-          const rebinds2 = emitArrMutatorRebinds(fn.body, fnBodyOpts, "  ");
+          const rebinds2 = emitArrMutatorRebinds(fn2.body, fnBodyOpts, "  ");
           const inner = [
             ...allPrologue,
             ...rebinds2.map((l) => `  ${l}`),
-            `  return ${fn.async ? `$async(() => ${bodySrc})` : bodySrc};`
+            `  return ${fn2.async ? `$async(() => ${bodySrc})` : bodySrc};`
           ].join("\n");
           if (hasThis) {
             const wrap = `function (${argsParamParts.join(", ")}) {
@@ -9417,17 +9496,17 @@ ${inner}
 ${inner}
 }, { ctor: ${fnCtor} })`;
         }
-        const rebinds = emitArrMutatorRebinds(fn.body, fnBodyOpts, "  ");
+        const rebinds = emitArrMutatorRebinds(fn2.body, fnBodyOpts, "  ");
         if (rebinds.length > 0) {
           const inner = [
             ...rebinds.map((l) => `  ${l}`),
-            `  return ${fn.async ? `$async(() => ${bodySrc})` : bodySrc};`
+            `  return ${fn2.async ? `$async(() => ${bodySrc})` : bodySrc};`
           ].join("\n");
           return `$fnVal(${nameList}, (${argsParamParts.join(", ")}) => {
 ${inner}
 }, { ctor: ${fnCtor} })`;
         }
-        if (fn.async) {
+        if (fn2.async) {
           return `$fnVal(${nameList}, (${argsParamParts.join(", ")}) => $async(() => ${bodySrc}), { ctor: ${fnCtor} })`;
         }
         return `$fnVal(${nameList}, (${argsParamParts.join(", ")}) => ${bodySrc}, { ctor: ${fnCtor} })`;
@@ -9742,9 +9821,9 @@ var BOOLEAN_PROTO_METHODS = /* @__PURE__ */ new Set(["toString", "valueOf"]);
 var SYMBOL_PROTO_METHODS = /* @__PURE__ */ new Set(["toString", "valueOf"]);
 var BIGINT_PROTO_METHODS = /* @__PURE__ */ new Set(["toString", "toLocaleString", "valueOf"]);
 function notePrimMemberMissing(recv, name, kind, loc) {
-  const shape = recv?.shape;
-  if (!shape || shape.k !== "prim") return false;
-  const t = shape.type;
+  const shape2 = recv?.shape;
+  if (!shape2 || shape2.k !== "prim") return false;
+  const t = shape2.type;
   if (OBJECT_PROTO_NAMES.has(name)) return false;
   const protoMethods = t === "string" ? STRING_METHODS : t === "number" ? NUMBER_PROTO_METHODS : t === "boolean" ? BOOLEAN_PROTO_METHODS : t === "symbol" ? SYMBOL_PROTO_METHODS : t === "bigint" ? BIGINT_PROTO_METHODS : void 0;
   if (!protoMethods) return false;
@@ -9866,9 +9945,9 @@ function runWithEvalMissingSlot(enabled, body) {
 }
 function noteObjSlotMissing(recv, name, loc) {
   if (!isEvalMissingSlotEnabled()) return false;
-  const shape = recv?.shape;
-  if (!shape || shape.k !== "obj") return false;
-  const obj2 = shape;
+  const shape2 = recv?.shape;
+  if (!shape2 || shape2.k !== "obj") return false;
+  const obj2 = shape2;
   if (obj2.open) return false;
   if (obj2.slots && Object.prototype.hasOwnProperty.call(obj2.slots, name)) return false;
   const conf = recv?.conf;
@@ -10760,23 +10839,23 @@ function clampWindow(len, target, start, end) {
   if (count <= 0) return null;
   return { t, s, e: s + count };
 }
-function copyWithinTuple(shape, vals) {
+function copyWithinTuple(shape2, vals) {
   validateIndexArg(vals[0], "copyWithin target may not be convertible to a number");
   validateIndexArg(vals[1], "copyWithin start may not be convertible to a number");
   validateIndexArg(vals[2], "copyWithin end may not be convertible to a number");
   const t = toIOI(vals[0]);
   const s = toIOI(vals[1]);
   const e = toIOI(vals[2]);
-  if (shape.k === "tuple") {
+  if (shape2.k === "tuple") {
     if (t === null || s === null || e === null) {
-      const joined = shape.elements.length ? shape.elements.reduce((x, y) => joinAbs(x, y)) : unknown;
+      const joined = shape2.elements.length ? shape2.elements.reduce((x, y) => joinAbs(x, y)) : unknown;
       return abs({ k: "arr", element: joined }, void 0, void 0, "partial");
     }
-    const len = shape.elements.length;
+    const len = shape2.elements.length;
     const win = clampWindow(len, t ?? 0, s ?? 0, e ?? len);
-    const origHoles = shape.holes ?? [];
+    const origHoles = shape2.holes ?? [];
     if (win) {
-      const els = [...shape.elements];
+      const els = [...shape2.elements];
       const holesSet = new Set(origHoles);
       const backwards = win.s < win.t && win.s + (win.e - win.s) > win.t;
       const count = win.e - win.s;
@@ -10804,7 +10883,7 @@ function copyWithinTuple(shape, vals) {
     return abs(
       {
         k: "tuple",
-        elements: [...shape.elements],
+        elements: [...shape2.elements],
         holes: origHoles.length > 0 ? [...origHoles] : void 0
       },
       void 0,
@@ -10812,19 +10891,19 @@ function copyWithinTuple(shape, vals) {
       "path"
     );
   }
-  return abs({ k: "arr", element: shape.element }, void 0, void 0, "partial");
+  return abs({ k: "arr", element: shape2.element }, void 0, void 0, "partial");
 }
-function fillTuple(shape, vals, arr) {
+function fillTuple(shape2, vals, arr) {
   validateIndexArg(vals[1], "fill start may not be convertible to a number");
   validateIndexArg(vals[2], "fill end may not be convertible to a number");
   const v2 = vals[0] ?? unknown;
   const s = toIOI(vals[1]);
   const e = toIOI(vals[2]);
-  if (shape.k === "tuple") {
-    const len = shape.elements.length;
+  if (shape2.k === "tuple") {
+    const len = shape2.elements.length;
     if (s === null || e === null) {
       return abs(
-        { k: "tuple", elements: shape.elements.map((el) => joinAbs(el, v2)) },
+        { k: "tuple", elements: shape2.elements.map((el) => joinAbs(el, v2)) },
         void 0,
         void 0,
         "partial"
@@ -10832,16 +10911,16 @@ function fillTuple(shape, vals, arr) {
     }
     const start = Math.max(Math.min((s ?? 0) < 0 ? len + (s ?? 0) : s ?? 0, len), 0);
     const end = Math.max(Math.min((e ?? len) < 0 ? len + (e ?? len) : e ?? len, len), 0);
-    const holes = (shape.holes ?? []).filter((h) => h < start || h >= end);
+    const holes = (shape2.holes ?? []).filter((h) => h < start || h >= end);
     if (end <= start) {
       return abs(
-        { k: "tuple", elements: [...shape.elements], holes: holes.length > 0 ? holes : void 0 },
+        { k: "tuple", elements: [...shape2.elements], holes: holes.length > 0 ? holes : void 0 },
         void 0,
         void 0,
         "path"
       );
     }
-    const els = shape.elements.map((el, i) => i >= start && i < end ? v2 : el);
+    const els = shape2.elements.map((el, i) => i >= start && i < end ? v2 : el);
     return abs(
       { k: "tuple", elements: els, holes: holes.length > 0 ? holes : void 0 },
       void 0,
@@ -10851,7 +10930,7 @@ function fillTuple(shape, vals, arr) {
   }
   const coversAll = (s === void 0 || s === 0) && e === void 0;
   return abs(
-    { k: "arr", element: coversAll ? v2 : joinAbs(shape.element, v2) },
+    { k: "arr", element: coversAll ? v2 : joinAbs(shape2.element, v2) },
     void 0,
     void 0,
     confJoin(arr.conf, coversAll ? arr.conf : "path")
@@ -10890,6 +10969,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);
@@ -10914,8 +10995,8 @@ function $copy(a) {
   return a;
 }
 function $arrMutContainer(arr, method, args) {
-  const shape = arr.shape;
-  if (shape.k !== "tuple" && shape.k !== "arr") return arr;
+  const shape2 = arr.shape;
+  if (shape2.k !== "tuple" && shape2.k !== "arr") return arr;
   const st = extStateOf(arr);
   if (st === "frozen") throwStrictWrite();
   if ((st === "sealed" || st === "nonext") && (method === "push" || method === "unshift" || method === "splice")) {
@@ -10925,9 +11006,9 @@ function $arrMutContainer(arr, method, args) {
   const asArrEl = (els) => els.length > 0 ? els.reduce((x, y) => joinAbs(x, y)) : unknown;
   const writeBack = (next) => writeInPlace(arr, next);
   if (method === "push" || method === "unshift") {
-    if (shape.k === "tuple") {
-      const els = method === "push" ? [...shape.elements, ...vals] : [...vals, ...shape.elements];
-      const holes = shape.holes ? shape.holes.map((h) => method === "push" ? h : h + vals.length) : void 0;
+    if (shape2.k === "tuple") {
+      const els = method === "push" ? [...shape2.elements, ...vals] : [...vals, ...shape2.elements];
+      const holes = shape2.holes ? shape2.holes.map((h) => method === "push" ? h : h + vals.length) : void 0;
       const conf = vals.reduce(
         (acc, v2) => confJoin(acc, v2.conf),
         arr.conf
@@ -10936,19 +11017,19 @@ function $arrMutContainer(arr, method, args) {
         abs({ k: "tuple", elements: els, holes }, void 0, void 0, conf)
       );
     }
-    const el = vals.reduce((acc, v2) => joinAbs(acc, v2), shape.element);
+    const el = vals.reduce((acc, v2) => joinAbs(acc, v2), shape2.element);
     return writeBack(
       abs({ k: "arr", element: el }, void 0, void 0, confJoin(arr.conf, "path"))
     );
   }
   if (method === "pop") {
-    if (shape.k === "tuple") {
-      if (shape.elements.length === 0) return arr;
-      const newLen = shape.elements.length - 1;
-      const holes = shape.holes ? shape.holes.filter((h) => h < newLen) : void 0;
+    if (shape2.k === "tuple") {
+      if (shape2.elements.length === 0) return arr;
+      const newLen = shape2.elements.length - 1;
+      const holes = shape2.holes ? shape2.holes.filter((h) => h < newLen) : void 0;
       return writeBack(
         abs(
-          { k: "tuple", elements: shape.elements.slice(0, -1), holes: holes && holes.length > 0 ? holes : void 0 },
+          { k: "tuple", elements: shape2.elements.slice(0, -1), holes: holes && holes.length > 0 ? holes : void 0 },
           void 0,
           void 0,
           arr.conf
@@ -10958,12 +11039,12 @@ function $arrMutContainer(arr, method, args) {
     return arr;
   }
   if (method === "shift") {
-    if (shape.k === "tuple") {
-      if (shape.elements.length === 0) return arr;
-      const holes = shape.holes ? shape.holes.map((h) => h - 1).filter((h) => h >= 0) : void 0;
+    if (shape2.k === "tuple") {
+      if (shape2.elements.length === 0) return arr;
+      const holes = shape2.holes ? shape2.holes.map((h) => h - 1).filter((h) => h >= 0) : void 0;
       return writeBack(
         abs(
-          { k: "tuple", elements: shape.elements.slice(1), holes: holes && holes.length > 0 ? holes : void 0 },
+          { k: "tuple", elements: shape2.elements.slice(1), holes: holes && holes.length > 0 ? holes : void 0 },
           void 0,
           void 0,
           arr.conf
@@ -10975,10 +11056,10 @@ function $arrMutContainer(arr, method, args) {
   if (method === "splice") {
     validateIndexArg(vals[0], "splice start may not be convertible to a number");
     validateIndexArg(vals[1], "splice deleteCount may not be convertible to a number");
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       return writeBack(
         abs(
-          { k: "arr", element: asArrEl(shape.elements) },
+          { k: "arr", element: asArrEl(shape2.elements) },
           void 0,
           void 0,
           confJoin(arr.conf, "path")
@@ -10988,12 +11069,12 @@ function $arrMutContainer(arr, method, args) {
     return arr;
   }
   if (method === "reverse") {
-    if (shape.k === "tuple") {
-      const len = shape.elements.length;
-      const holes = shape.holes ? shape.holes.map((h) => len - 1 - h) : void 0;
+    if (shape2.k === "tuple") {
+      const len = shape2.elements.length;
+      const holes = shape2.holes ? shape2.holes.map((h) => len - 1 - h) : void 0;
       return writeBack(
         abs(
-          { k: "tuple", elements: [...shape.elements].reverse(), holes },
+          { k: "tuple", elements: [...shape2.elements].reverse(), holes },
           void 0,
           void 0,
           arr.conf
@@ -11003,19 +11084,19 @@ function $arrMutContainer(arr, method, args) {
     return arr;
   }
   if (method === "copyWithin") {
-    return writeBack(copyWithinTuple(shape, vals));
+    return writeBack(copyWithinTuple(shape2, vals));
   }
   if (method === "fill") {
-    return writeBack(fillTuple(shape, vals, arr));
+    return writeBack(fillTuple(shape2, vals, arr));
   }
   if (method === "sort") {
     validateCallableArg(vals[0], "sort comparator may not be callable", {
       undefinedOk: true
     });
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       return writeBack(
         abs(
-          { k: "arr", element: asArrEl(shape.elements) },
+          { k: "arr", element: asArrEl(shape2.elements) },
           void 0,
           void 0,
           confJoin(arr.conf, "path")
@@ -11282,9 +11363,9 @@ function $spread(a, b) {
   if (acc && bb.shape.k === "obj") {
     let changed = false;
     const slots = { ...bb.shape.slots };
-    for (const [k, fn] of acc) {
-      if (fn.get) {
-        setSlot(slots, k, { value: fn.get(bb) });
+    for (const [k, fn2] of acc) {
+      if (fn2.get) {
+        setSlot(slots, k, { value: fn2.get(bb) });
         changed = true;
       }
     }
@@ -11342,8 +11423,8 @@ function $objRest(o, keys) {
   }
   if (!isObj(o)) {
     if (o.shape.k === "any") {
-      const shape2 = { k: "obj", slots: {}, open: true };
-      return { shape: shape2, conf: "partial" };
+      const shape3 = { k: "obj", slots: {}, open: true };
+      return { shape: shape3, conf: "partial" };
     }
     return unknown;
   }
@@ -11355,9 +11436,9 @@ function $objRest(o, keys) {
     setSlot(slots, k, s);
   }
   if (o.shape.open) openRest = true;
-  const shape = { k: "obj", slots };
-  if (openRest) shape.open = true;
-  return { shape, conf: o.conf === "exact" ? "exact" : confJoin(o.conf, "partial") };
+  const shape2 = { k: "obj", slots };
+  if (openRest) shape2.open = true;
+  return { shape: shape2, conf: o.conf === "exact" ? "exact" : confJoin(o.conf, "partial") };
 }
 function $arrRest(a, start) {
   const mi = matchIterElements(a);
@@ -11563,30 +11644,30 @@ function elemsOf(a) {
   return [unknown];
 }
 function $forInKeys(o) {
-  const shape = o.shape;
-  if (shape.k === "sum") {
-    const members = shape.members.map((m) => $forInKeys(m));
+  const shape2 = o.shape;
+  if (shape2.k === "sum") {
+    const members = shape2.members.map((m) => $forInKeys(m));
     return members.length ? members.reduce((a, b) => joinAbs(a, b)) : unknown;
   }
   const isArrayIndexKey = (k) => {
     const n = Number(k);
     return k !== "" && String(n) === k && Number.isInteger(n) && n >= 0 && n < 4294967295;
   };
-  if (shape.k === "obj") {
-    const keys = enumOwnKeys(o, shape.slots);
+  if (shape2.k === "obj") {
+    const keys = enumOwnKeys(o, shape2.slots);
     const intKeys = keys.filter(isArrayIndexKey).sort((a, b) => Number(a) - Number(b));
     const strKeys = keys.filter((k) => !isArrayIndexKey(k));
     return $arr([...intKeys, ...strKeys].map((k) => $lit(k)));
   }
-  if (shape.k === "tuple") {
+  if (shape2.k === "tuple") {
     const idxs = [];
-    for (let i = 0; i < shape.elements.length; i++) {
-      if (shape.holes?.includes(i)) continue;
+    for (let i = 0; i < shape2.elements.length; i++) {
+      if (shape2.holes?.includes(i)) continue;
       idxs.push(i);
     }
     return $arr(idxs.map((i) => $lit(String(i))));
   }
-  if (shape.k === "arr") {
+  if (shape2.k === "arr") {
     return abs({ k: "arr", element: $lit("0") }, void 0, void 0, "partial");
   }
   const svR = litValue(o);
@@ -11595,11 +11676,11 @@ function $forInKeys(o) {
     return $arr(Array.from({ length: sv.length }, (_, i) => $lit(String(i))));
   }
   const isNullishLit2 = o.term?.op === "lit" && (o.term.value === null || o.term.value === void 0);
-  if (!isNullishLit2 && (shape.k === "any" || shape.k === "unknown" || shape.k === "prim" && shape.type === "string")) {
+  if (!isNullishLit2 && (shape2.k === "any" || shape2.k === "unknown" || shape2.k === "prim" && shape2.type === "string")) {
     return abs({ k: "arr", element: str() }, void 0, void 0, "partial");
   }
-  if (shape.k === "brand") {
-    const inner = shape.shape;
+  if (shape2.k === "brand") {
+    const inner = shape2.shape;
     if (inner.shape.k === "obj") {
       const keys = enumOwnKeys(inner, inner.shape.slots);
       return $arr(keys.map((k) => $lit(k)));
@@ -11625,9 +11706,9 @@ function $forOf(iterable, body, maxIters = DEFAULT_MAX_LOOP_ITERS, opts) {
     if (!exitJoin || !pack || !unpack) return;
     unpack(joinAbs(exitJoin, pack()));
   };
-  const shape = iterable.shape;
+  const shape2 = iterable.shape;
   const forAwait = opts?.forAwait === true;
-  const asyncOnly = forAwait && shape.k === "obj" && !shape.slots["@@iterator"] && !!shape.slots["@@asyncIterator"];
+  const asyncOnly = forAwait && shape2.k === "obj" && !shape2.slots["@@iterator"] && !!shape2.slots["@@asyncIterator"];
   if (forAwait) {
     const kind = asyncIterabilityKind(iterable);
     if (kind === "definite") throw new NudoThrow(errorTypeAbs("TypeError"));
@@ -11642,7 +11723,7 @@ function $forOf(iterable, body, maxIters = DEFAULT_MAX_LOOP_ITERS, opts) {
   const items = asyncOnly ? [unknown] : forAwait ? elemsOf(iterable).map(awaitElem) : $elems(iterable);
   const svR = litValue(iterable);
   const sv = svR.ok ? svR.value : void 0;
-  const knownLen = shape.k === "tuple" ? shape.elements.length : typeof sv === "string" ? [...sv].length : collectionExactLen(iterable) ?? sideIterLen(iterable);
+  const knownLen = shape2.k === "tuple" ? shape2.elements.length : typeof sv === "string" ? [...sv].length : collectionExactLen(iterable) ?? sideIterLen(iterable);
   const unbounded = knownLen === void 0;
   if (unbounded) snapExit();
   const concreteCap = Math.max(maxIters, MAX_CONCRETE_LOOP_ITERS);
@@ -12061,9 +12142,9 @@ function $set(o, key, value) {
     }
     return o;
   }
-  const shape = o.shape;
+  const shape2 = o.shape;
   const st = extStateOf(o);
-  const hasKey = Object.prototype.hasOwnProperty.call(shape.slots, key);
+  const hasKey = Object.prototype.hasOwnProperty.call(shape2.slots, key);
   if (st === "frozen") throwStrictWrite();
   if ((st === "sealed" || st === "nonext") && !hasKey) throwStrictWrite();
   if (getPropFlags(o)?.get(key)?.writable === false) throwStrictWrite();
@@ -12075,7 +12156,7 @@ function $set(o, key, value) {
   if (key === "__proto__" && !isNullProtoObj(o)) {
     return $setProto(o, value);
   }
-  setSlot(shape.slots, key, { value: asAbsVal(value) });
+  setSlot(shape2.slots, key, { value: asAbsVal(value) });
   o.conf = confJoin(o.conf, value.conf);
   clearStaleTermPred(o);
   return o;
@@ -12235,7 +12316,7 @@ function instanceOf(left, rightClassName, env) {
     term: { op: "lit", value: v2 },
     conf: "exact"
   });
-  const partial = () => ({ shape: { k: "prim", type: "boolean" }, conf: "partial" });
+  const partial2 = () => ({ shape: { k: "prim", type: "boolean" }, conf: "partial" });
   switch (left.shape.k) {
     case "brand": {
       if (rightClassName === "Object") return t(true);
@@ -12245,28 +12326,28 @@ function instanceOf(left, rightClassName, env) {
     case "tuple":
       if (rightClassName === "Array" || rightClassName === "Object") return t(true);
       if (BUILTIN_CTOR_NAMES2.has(rightClassName)) return t(false);
-      return partial();
+      return partial2();
     // 可能是 Array 子类
     case "obj":
       if (rightClassName === "Object") return t(true);
       if (BUILTIN_CTOR_NAMES2.has(rightClassName)) return t(false);
-      return partial();
+      return partial2();
     case "fn":
       if (rightClassName === "Function" || rightClassName === "Object") return t(true);
       if (BUILTIN_CTOR_NAMES2.has(rightClassName)) return t(false);
-      return partial();
+      return partial2();
     case "eff":
       if (left.shape.eff === "promise") {
         if (rightClassName === "Promise" || rightClassName === "Object") return t(true);
         if (BUILTIN_CTOR_NAMES2.has(rightClassName)) return t(false);
-        return partial();
+        return partial2();
       }
       if (left.shape.eff === "generator") {
         if (rightClassName === "Generator" || rightClassName === "Object") return t(true);
         if (BUILTIN_CTOR_NAMES2.has(rightClassName)) return t(false);
-        return partial();
+        return partial2();
       }
-      return partial();
+      return partial2();
     case "prim":
       return t(false);
     // 原始值无装箱
@@ -12625,13 +12706,13 @@ function setGenJoinOverride(v2) {
 function bumpGenPathSensitive() {
   genPathSensitive++;
 }
-function withIsolatedYields(fn) {
+function withIsolatedYields(fn2) {
   const top = yieldStack[yieldStack.length - 1];
-  if (!top) return { v: fn(), ys: null };
+  if (!top) return { v: fn2(), ys: null };
   const armYs = [];
   yieldStack[yieldStack.length - 1] = armYs;
   try {
-    return { v: fn(), ys: armYs };
+    return { v: fn2(), ys: armYs };
   } finally {
     yieldStack[yieldStack.length - 1] = top;
   }
@@ -13054,10 +13135,10 @@ function $switch(disc, cases, dflt) {
   beginCollectionFork();
   const armOverlays2 = [];
   const armYsList = [];
-  const runArm = (fn) => {
+  const runArm = (fn2) => {
     pushCollectionArm();
     try {
-      const r = withIsolatedYields(() => runForkArm(fn, exits));
+      const r = withIsolatedYields(() => runForkArm(fn2, exits));
       armYsList.push(r.ys);
       return r.v;
     } finally {
@@ -13503,6 +13584,773 @@ var BoundedLruMap = class {
   }
 };
 
+// src/algebra/constraint.ts
+var SELF = "__nudo_self__";
+function selfTerm() {
+  return v(SELF);
+}
+function getTerm(obj2, key) {
+  return app("get", [obj2, lit(key)]);
+}
+function lenTerm(t) {
+  return app("length", [t]);
+}
+function isConstraint(x) {
+  return !!x && typeof x === "object" && x.__nudoConstraint === true;
+}
+function isNudoConstraint(x) {
+  return isConstraint(x);
+}
+var intFlaggedBuilders = /* @__PURE__ */ new WeakSet();
+function isIntFlag(c) {
+  return c.int === true || intFlaggedBuilders.has(c);
+}
+function makeBuilder(prim, preds, extra) {
+  const fields = extra?.fields;
+  const element = extra?.element;
+  const isInt = extra?.int;
+  const optional = extra?.optional;
+  const members = extra?.members;
+  const fnSlot = extra?.fn;
+  const lazySlot = extra?.lazy;
+  const base = {
+    __nudoConstraint: true,
+    ...prim ? { prim } : {},
+    preds: [...preds],
+    ...fields ? { fields } : {},
+    ...element ? { element } : {},
+    ...optional ? { isOptional: true } : {},
+    ...members ? { members } : {},
+    ...fnSlot ? { fn: fnSlot } : {},
+    ...lazySlot ? { lazy: lazySlot } : {}
+  };
+  const add2 = (p) => makeBuilder(prim, [...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(prim ?? "number", preds, { ...extra, int: true }),
+      min: (n) => add2(ge(lenTerm(selfTerm()), lit(n))),
+      max: (n) => add2(le(lenTerm(selfTerm()), lit(n))),
+      length: (n) => add2(and(ge(lenTerm(selfTerm()), lit(n)), le(lenTerm(selfTerm()), lit(n)))),
+      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 (prim !== void 0 && prim !== "number")
+          throw new Error(`nudo shift(): only numeric chains are allowed (prim=${prim})`);
+        return makeBuilder(prim, shiftBoundPreds(preds, n), extra);
+      },
+      optional: () => makeBuilder(prim, preds, { ...extra, optional: true })
+    }
+  );
+  if (isInt) intFlaggedBuilders.add(builder);
+  return builder;
+}
+function shiftBoundPreds(preds, n) {
+  return preds.map((p) => {
+    if (p.op !== "gt" && p.op !== "ge" && p.op !== "lt" && p.op !== "le")
+      throw new Error(`nudo shift(): predicate ${p.op} is not supported (only gt/ge/lt/le constant bounds)`);
+    const { a, b } = p;
+    if (b.op !== "lit" || typeof b.value !== "number")
+      throw new Error("nudo shift(): the right-hand side of a constant bound must be a numeric literal");
+    if (termHasApp(a, "length") || termHasApp(b, "length"))
+      throw new Error("nudo shift(): length(...) bounds are not supported");
+    return { op: p.op, a, b: lit(b.value + n) };
+  });
+}
+function termHasApp(t, fn2) {
+  if (t.op !== "app") return false;
+  if (t.fn === fn2) return true;
+  return t.args.some((x) => termHasApp(x, fn2));
+}
+function number() {
+  return makeBuilder("number", []);
+}
+function string() {
+  return makeBuilder("string", []);
+}
+function boolean() {
+  return makeBuilder("boolean", []);
+}
+function any() {
+  return makeBuilder(void 0, []);
+}
+function array(item) {
+  return makeBuilder(void 0, [], {
+    element: asNestedConstraint(item, "array(item)")
+  });
+}
+function shape(fields) {
+  const mapped = {};
+  for (const [k, v2] of Object.entries(fields)) {
+    const constraint = asNestedConstraint(v2, `shape \u5B57\u6BB5 '${k}'`);
+    mapped[k] = {
+      constraint,
+      ...constraint.isOptional ? { optional: true } : {}
+    };
+  }
+  return makeBuilder(void 0, [], { fields: mapped });
+}
+function toPlainConstraint(c) {
+  if (!isConstraint(c))
+    throw new Error("nudo: expected a constraint value (number()/string()/\u2026 or a combinator)");
+  return {
+    __nudoConstraint: true,
+    ...c.prim ? { prim: c.prim } : {},
+    preds: [...c.preds],
+    ...c.fields ? { fields: c.fields } : {},
+    ...c.element ? { element: c.element } : {},
+    // isIntFlag 统一读取：builder（int 是方法）查 WeakSet，纯数据看 === true
+    ...isIntFlag(c) ? { int: true } : {},
+    ...c.isOptional ? { isOptional: true } : {},
+    ...c.members ? { members: c.members } : {},
+    ...c.fn ? { fn: c.fn } : {},
+    ...c.lazy ? { lazy: c.lazy } : {}
+  };
+}
+function litC(v2) {
+  const prim = typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : typeof v2 === "boolean" ? "boolean" : void 0;
+  return makeBuilder(prim, [eq(selfTerm(), lit(v2))]);
+}
+function asNestedConstraint(x, 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 });
+}
+var LAZY_TEMPLATE_DEPTH = 3;
+var lazyDerefMemo = /* @__PURE__ */ new WeakMap();
+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 prim;
+  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 (prim !== void 0 && prim !== c.prim)
+        throw new Error(`nudo and(): inconsistent prim (${prim} vs ${c.prim})`);
+      prim = c.prim;
+    }
+    preds.push(...c.preds);
+    if (isIntFlag(c)) isInt = true;
+    if (!c.isOptional) allOptional = false;
+  }
+  return makeBuilder(prim, preds, {
+    ...isInt ? { int: true } : {},
+    ...allOptional ? { optional: true } : {}
+  });
+}
+function partial(c) {
+  if (!isConstraint(c))
+    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 });
+}
+var CONSTRAINT_BUILDERS = {
+  number,
+  string,
+  boolean,
+  any,
+  array,
+  shape,
+  lit: litC,
+  union,
+  nullable,
+  lazy,
+  fn,
+  and: andC,
+  partial,
+  pick,
+  omit
+};
+var CONSTRAINT_BUILDER_NAMES = Object.keys(
+  CONSTRAINT_BUILDERS
+);
+var CONSTRAINT_EXPR_RE = new RegExp(
+  `^(${CONSTRAINT_BUILDER_NAMES.join("|")})\\s*\\(`
+);
+function substTerm(t, paramName) {
+  if (t.op === "var" && t.id === SELF) return v(paramName);
+  if (t.op === "app" && t.fn === "get" && t.args.length === 2) {
+    return getTerm(substTerm(t.args[0], paramName), String(
+      t.args[1].op === "lit" ? t.args[1].value : ""
+    ));
+  }
+  return t;
+}
+function substPred2(p, paramName) {
+  switch (p.op) {
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+    case "eq":
+    case "ne": {
+      return { op: p.op, a: substTerm(p.a, paramName), b: substTerm(p.b, paramName) };
+    }
+    case "typeof": {
+      return { op: "typeof", t: substTerm(p.t, paramName), type: p.type };
+    }
+    case "and":
+      return and(...p.args.map((x) => substPred2(x, paramName)));
+    default:
+      return p;
+  }
+}
+function instantiateConstraint(c, paramName, depth = LAZY_TEMPLATE_DEPTH) {
+  if (c.lazy) {
+    if (depth <= 0) return pTrue;
+    return instantiateConstraint(derefConstraint(c), paramName, 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(paramName), key);
+      parts.push(instantiateOnTerm(field.constraint, fieldTerm, depth));
+    }
+    if (c.prim) parts.push(ptypeof(v(paramName), primToTypeof(c.prim)));
+    if (parts.length === 0) return { op: "true" };
+    return parts.length === 1 ? parts[0] : and(...parts);
+  }
+  if (c.members) {
+    const disj = or(
+      ...c.members.map((m) => instantiateOnTerm(m, v(paramName), depth))
+    );
+    const own = c.preds.map((p) => substPred2(p, paramName));
+    return own.length === 0 ? disj : and(...own, disj);
+  }
+  if (c.fn) {
+    const own = c.preds.map((p) => substPred2(p, paramName));
+    return own.length === 0 ? pTrue : and(...own);
+  }
+  const preds = c.preds.map((p) => substPred2(p, paramName));
+  if (c.prim && c.preds.length === 0) {
+    return ptypeof(v(paramName), primToTypeof(c.prim));
+  }
+  return preds.length === 0 ? { op: "true" } : preds.length === 1 ? preds[0] : and(...preds);
+}
+function instantiateOnTerm(c, t, 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 tt = p.t.op === "var" && p.t.id === SELF ? t : p.t;
+        return { op: "typeof", t: tt, type: p.type };
+      }
+      case "and":
+        return and(...p.args.map(subst));
+      default:
+        return p;
+    }
+  };
+  if (c.fields) {
+    const parts = [];
+    for (const [key, field] of Object.entries(c.fields)) {
+      if (field.optional || field.constraint.isOptional) continue;
+      parts.push(instantiateOnTerm(field.constraint, getTerm(t, key), 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, paramName, depth = LAZY_TEMPLATE_DEPTH) {
+  const t = v(paramName);
+  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 visit = (p2) => {
+    if (p2.op === "and") {
+      p2.args.forEach(visit);
+      return;
+    }
+    leaves.push(p2);
+  };
+  m.preds.forEach(visit);
+  if (leaves.length !== 1) return { ok: false };
+  const p = leaves[0];
+  if (p.op !== "eq") return { ok: false };
+  if (p.a.op === "var" && p.b.op === "lit") {
+    return { ok: true, v: p.b.value };
+  }
+  if (p.b.op === "var" && p.a.op === "lit") {
+    return { ok: true, v: p.a.value };
+  }
+  return { ok: false };
+}
+function samePrimLiteralUnionAbs(members, t) {
+  if (members.length === 0) return void 0;
+  const values = [];
+  let prim;
+  for (const m of members) {
+    const mk = memberLitValue(m);
+    if (!mk.ok) return void 0;
+    const v2 = mk.v;
+    if (v2 === void 0 || v2 === null) return void 0;
+    const mp = m.prim ?? (typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : "boolean");
+    if (prim === void 0) prim = mp;
+    else if (prim !== mp) return void 0;
+    values.push(v2);
+  }
+  if (prim === void 0) return void 0;
+  const uniq = [];
+  for (const v2 of values) {
+    if (!uniq.some((u) => Object.is(u, v2))) uniq.push(v2);
+  }
+  const disj = or(
+    ...uniq.map((v2) => eq(t, lit(v2)))
+  );
+  return abs({ k: "prim", type: prim }, t, disj, "path");
+}
+function constraintOnTermAbs(c, t, 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;
+}
+
+// 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(prim, lv) {
+  switch (prim) {
+    case "number":
+      return typeof lv === "number";
+    case "string":
+      return typeof lv === "string";
+    case "boolean":
+      return typeof lv === "boolean";
+    case "object":
+      return lv === null;
+    case "undefined":
+      return lv === void 0;
+    default:
+      return false;
+  }
+}
+function predHolds(lv, p) {
+  switch (p.op) {
+    case "eq": {
+      const litT = isSelfVar(p.a) && p.b.op === "lit" ? p.b : isSelfVar(p.b) && p.a.op === "lit" ? p.a : void 0;
+      if (!litT) return false;
+      return Object.is(lv, litT.value);
+    }
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+      return boundHolds(lv, p);
+    case "typeof":
+      return p.t.op === "var" && p.t.id === SELF && primMatches(p.type, lv);
+    // and 是合取：逐参数按同一规则判定（string().length(n) 的 preds 是
+    // and 包裹的两个长度界，叶子仍是 gt/ge/lt/le，无假阳性风险）
+    case "and":
+      return p.args.every((x) => predHolds(lv, x));
+    // ne / or / not / true / false 等其余形态：保守不满足
+    default:
+      return false;
+  }
+}
+function cmpHolds(x, op, n) {
+  switch (op) {
+    case "gt":
+      return x > n;
+    case "ge":
+      return x >= n;
+    case "lt":
+      return x < n;
+    case "le":
+      return x <= n;
+  }
+}
+function boundHolds(lv, p) {
+  if (p.b.op !== "lit" || typeof p.b.value !== "number") return false;
+  const n = p.b.value;
+  if (isLengthSelf(p.a)) {
+    return typeof lv === "string" && cmpHolds(lv.length, p.op, n);
+  }
+  if (isSelfVar(p.a)) {
+    return typeof lv === "number" && cmpHolds(lv, p.op, n);
+  }
+  return false;
+}
+function isSelfVar(t) {
+  return t.op === "var" && t.id === SELF;
+}
+function isLengthSelf(t) {
+  return t.op === "app" && t.fn === "length" && t.args.length === 1 && isSelfVar(t.args[0]);
+}
+
+// src/algebra/contract-face.ts
+var facesByFn = /* @__PURE__ */ new WeakMap();
+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);
+}
+var contractFaceResolverSlot = createScopedSlot(
+  () => null
+);
+registerCollectorScopeParticipant(
+  (body) => contractFaceResolverSlot.runScoped(body)
+);
+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;
+}
+
 // src/algebra/exec/calls.ts
 var PURE_CALL_MEMO_MAX = 256;
 var pureCallMemo = /* @__PURE__ */ new WeakMap();
@@ -13589,16 +14437,16 @@ var NEVER_EXEC_HOST_FN_NAMES = [
   "requestAnimationFrame",
   "requestIdleCallback"
 ];
-function neverExecHostName(fn) {
-  if (typeof fn !== "function") return null;
+function neverExecHostName(fn2) {
+  if (typeof fn2 !== "function") return null;
   const g = globalThis;
   for (const n of NEVER_EXEC_HOST_FN_NAMES) {
-    if (fn === g[n]) return n;
+    if (fn2 === g[n]) return n;
   }
   return null;
 }
-function blockHostSideEffect(fn) {
-  const hostName = neverExecHostName(fn);
+function blockHostSideEffect(fn2) {
+  const hostName = neverExecHostName(fn2);
   if (hostName === null) return null;
   noteHostEffectBlocked(hostName);
   return abs({ k: "unknown" }, void 0, void 0, "opaque");
@@ -13620,8 +14468,8 @@ function getEvalCallCollector() {
   return evalCallCollectorSlot.get();
 }
 var hostGlobalFnIds;
-function isHostGlobalFn(fn) {
-  if (typeof fn !== "function") return false;
+function isHostGlobalFn(fn2) {
+  if (typeof fn2 !== "function") return false;
   if (!hostGlobalFnIds) {
     hostGlobalFnIds = /* @__PURE__ */ new Set();
     const g = globalThis;
@@ -13630,9 +14478,9 @@ function isHostGlobalFn(fn) {
       if (typeof v2 === "function") hostGlobalFnIds.add(v2);
     }
   }
-  return hostGlobalFnIds.has(fn);
+  return hostGlobalFnIds.has(fn2);
 }
-function callHostGlobalLiteralOnly(name, fn, args) {
+function callHostGlobalLiteralOnly(name, fn2, args) {
   const jsArgs = [];
   for (const a of args) {
     if (a && typeof a === "object" && "shape" in a) {
@@ -13653,7 +14501,7 @@ function callHostGlobalLiteralOnly(name, fn, args) {
     }
   }
   try {
-    return asAbsVal(fn(...jsArgs));
+    return asAbsVal(fn2(...jsArgs));
   } catch (e) {
     throw new NudoThrow(throwPayloadOf(e));
   }
@@ -13726,12 +14574,12 @@ function getEvalCallBudgetState() {
 function evalTruncatedAbs() {
   return abs({ k: "unknown" }, void 0, void 0, "opaque");
 }
-function evalCallBudgetKey(name, fn, args) {
-  const id = fn && typeof fn === "object" ? evalStableId(fn) : "prim";
+function evalCallBudgetKey(name, fn2, args) {
+  const id = fn2 && typeof fn2 === "object" ? evalStableId(fn2) : "prim";
   return callBudgetKey(name, id, args);
 }
-function evalEnterCall(name, fn, args) {
-  const key = evalCallBudgetKey(name, fn, args);
+function evalEnterCall(name, fn2, args) {
+  const key = evalCallBudgetKey(name, fn2, args);
   if (evalActiveCallKeys.includes(key) || evalCallDepth >= evalCallDepthLimit || evalTotalCalls >= evalTotalCallsLimit) {
     noteAbsTruncation(name);
     return { ok: false };
@@ -13745,13 +14593,19 @@ function evalExitCall() {
   if (evalCallDepth > 0) evalCallDepth--;
   if (evalActiveCallKeys.length > 0) evalActiveCallKeys.pop();
 }
-function $callNamed(name, fn, args, loc, argLocs) {
-  const pureName = pureFnNameOf(fn);
-  const fnObj = fn && (typeof fn === "object" || typeof fn === "function") ? fn : void 0;
-  const pk = pureName && fnObj ? callBudgetKey("pure", "", args) : void 0;
+function $callNamed(name, fn2, args, loc, argLocs) {
+  const faces = resolveContractFacesByName(name) ?? contractFacesOf(fn2);
+  const fnObj = fn2 && (typeof fn2 === "object" || typeof fn2 === "function") ? fn2 : 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;
@@ -13767,42 +14621,42 @@ function $callNamed(name, fn, args, loc, argLocs) {
   );
   if (loc) pushCallLoc({ line: loc[0], column: loc[1] });
   try {
-    if (typeof fn === "function") {
+    if (typeof fn2 === "function") {
       let g;
-      if (GLOBAL_FNS.has(name) && fn === globalThis[name]) {
+      if (GLOBAL_FNS.has(name) && fn2 === globalThis[name]) {
         g = evalGlobalFn(name, args);
       } else {
-        const ctorName = hostBuiltinCtorName(fn);
+        const ctorName = hostBuiltinCtorName(fn2);
         if (ctorName !== void 0) {
           g = evalGlobalFn(ctorName, args);
         }
       }
-      const blockedHost = g === void 0 ? blockHostSideEffect(fn) : null;
+      const blockedHost = g === void 0 ? blockHostSideEffect(fn2) : null;
       if (g !== void 0) {
         result = g;
       } else if (blockedHost !== null) {
         result = blockedHost;
-      } else if (isHostGlobalFn(fn)) {
-        result = callHostGlobalLiteralOnly(name, fn, args);
+      } else if (isHostGlobalFn(fn2)) {
+        result = callHostGlobalLiteralOnly(name, fn2, args);
       } else {
-        const entered = evalEnterCall(name, fn, args);
+        const entered = evalEnterCall(name, fn2, execArgs);
         if (!entered.ok) {
           result = evalTruncatedAbs();
         } else {
           try {
-            result = callAtFunctionBoundary(() => fn(...args));
+            result = callAtFunctionBoundary(() => fn2(...execArgs));
           } finally {
             evalExitCall();
           }
         }
       }
-    } else if (fn && typeof fn === "object" && "shape" in fn) {
-      const entered = evalEnterCall(name, fn, args);
+    } else if (fn2 && typeof fn2 === "object" && "shape" in fn2) {
+      const entered = evalEnterCall(name, fn2, execArgs);
       if (!entered.ok) {
         result = evalTruncatedAbs();
       } else {
         try {
-          result = $call(fn, args);
+          result = $call(fn2, execArgs);
         } finally {
           evalExitCall();
         }
@@ -13836,7 +14690,7 @@ function $callNamed(name, fn, args, loc, argLocs) {
       }
     }
   }
-  return result;
+  return faces ? presentCallResultFace(result, faces) : result;
 }
 
 // src/algebra/methods.ts
@@ -14906,8 +15760,8 @@ function $new(cls, args) {
         popCtorFrame();
       }
     }
-    const shape = objOf({});
-    return abs({ k: "brand", name: clsName, shape }, void 0, void 0, "path");
+    const shape2 = objOf({});
+    return abs({ k: "brand", name: clsName, shape: shape2 }, void 0, void 0, "path");
   }
   const spec = specOf(cls);
   if (!spec) {
@@ -15183,12 +16037,12 @@ function $invokeInner(thisVal, method, args, loc) {
       return ["_rest"];
     };
     if (typeof thisVal === "function") {
-      const fn = thisVal;
+      const fn2 = thisVal;
       if (method === "call") {
-        return callAtFunctionBoundary(() => fn.apply(args[0], args.slice(1)));
+        return callAtFunctionBoundary(() => fn2.apply(args[0], args.slice(1)));
       }
       if (method === "apply") {
-        return callAtFunctionBoundary(() => fn.apply(args[0], expandApplyArgs(args[1])));
+        return callAtFunctionBoundary(() => fn2.apply(args[0], expandApplyArgs(args[1])));
       }
       const boundThis = args[0];
       const bound = args.slice(1);
@@ -15196,7 +16050,7 @@ function $invokeInner(thisVal, method, args, loc) {
       return absFunction(
         boundFnParams(thisVal, bound.length),
         {
-          apply: (callArgs) => callAtFunctionBoundary(() => fn.apply(boundThis, [...bound, ...callArgs]))
+          apply: (callArgs) => callAtFunctionBoundary(() => fn2.apply(boundThis, [...bound, ...callArgs]))
         },
         hostFacet !== void 0 ? { ctor: hostFacet } : void 0
       );
@@ -15450,9 +16304,9 @@ function $invokeInner(thisVal, method, args, loc) {
   noteUnknownMemberMissing(thisVal, method, "method", loc);
   return unknown;
 }
-function refineFnReturnType(fn, result) {
-  if (!fn || typeof fn !== "object" || !("shape" in fn)) return;
-  const s = fn.shape;
+function refineFnReturnType(fn2, result) {
+  if (!fn2 || typeof fn2 !== "object" || !("shape" in fn2)) return;
+  const s = fn2.shape;
   if (s.k !== "fn") return;
   if (s.returnType === void 0) {
     s.returnType = result;
@@ -15472,8 +16326,8 @@ function memberLikelyHasMethod(m, method) {
   return false;
 }
 function invokeArrMethod(arr, method, args) {
-  const shape = arr.shape;
-  const holes = shape.k === "tuple" ? arr.shape.holes ?? [] : [];
+  const shape2 = arr.shape;
+  const holes = shape2.k === "tuple" ? arr.shape.holes ?? [] : [];
   const isHole = (i) => holes.includes(i);
   const unknownIdx = () => abs({ k: "prim", type: "number" }, void 0, void 0, "path");
   const callbackTruth = (r) => {
@@ -15484,7 +16338,7 @@ function invokeArrMethod(arr, method, args) {
     if (typeof v2 === "number" && (v2 === 0 || Number.isNaN(v2))) return false;
     return true;
   };
-  const callFn = (fn, ...fnArgs) => {
+  const callFn = (fn2, ...fnArgs) => {
     const sumIdx = fnArgs.findIndex(
       (a) => a && typeof a === "object" && "shape" in a && a.shape.k === "sum"
     );
@@ -15493,24 +16347,24 @@ function invokeArrMethod(arr, method, args) {
       let acc;
       for (const m of members) {
         const next = fnArgs.map((a, i) => i === sumIdx ? m : a);
-        const r = callFn(fn, ...next);
+        const r = callFn(fn2, ...next);
         acc = acc === void 0 ? r : joinAbs(acc, r);
       }
       return acc ?? unknown;
     }
-    if (typeof fn === "function") {
-      const r = callAtFunctionBoundary(() => fn(...fnArgs));
+    if (typeof fn2 === "function") {
+      const r = callAtFunctionBoundary(() => fn2(...fnArgs));
       if (r && typeof r === "object" && "shape" in r) return r;
       return unknown;
     }
-    const absFn = asAbs(fn);
+    const absFn = asAbs(fn2);
     if (absFn) {
       return applyCallbackAbs(absFn, fnArgs, emptyEnv(), pTrue, defaultLeakBudget);
     }
     return unknown;
   };
-  const isRelationOnly = (fn) => {
-    const a = asAbs(fn);
+  const isRelationOnly = (fn2) => {
+    const a = asAbs(fn2);
     if (!a) return false;
     const impl = getFnImpl(a);
     if (impl?.body || impl?.apply) return false;
@@ -15518,8 +16372,8 @@ function invokeArrMethod(arr, method, args) {
   };
   if (method === "map") {
     validateCallableArg(args[0], "map callback may not be callable");
-    if (shape.k === "tuple") {
-      const mapped = shape.elements.map(
+    if (shape2.k === "tuple") {
+      const mapped = shape2.elements.map(
         (el2, i) => isHole(i) ? el2 : callFn(args[0], el2, $lit(i), arr)
       );
       return abs(
@@ -15529,70 +16383,70 @@ function invokeArrMethod(arr, method, args) {
         "path"
       );
     }
-    const out = callFn(args[0], shape.element, unknownIdx(), arr);
-    const el = mapElementFallback(asAbs(args[0]), shape.element, out);
+    const out = callFn(args[0], shape2.element, unknownIdx(), arr);
+    const el = mapElementFallback(asAbs(args[0]), shape2.element, out);
     const conf = el === out ? confJoin(arr.conf, out.conf) : "partial";
     return abs({ k: "arr", element: el }, void 0, void 0, conf);
   }
   if (method === "reduce") {
     validateCallableArg(args[0], "reduce callback may not be callable");
-    const fn = args[0];
+    const fn2 = args[0];
     const noInitial = args.length < 2;
     let acc = args[1] ?? unknown;
-    if (noInitial && shape.k === "arr") {
+    if (noInitial && shape2.k === "arr") {
       recordMayThrow({
         kind: "TypeError",
         cause: "reduce of possibly-empty array with no initial value"
       });
     }
-    if (isRelationOnly(fn) && shape.k === "arr") {
-      const d = instantiateReturn(fn, [acc, shape.element]);
+    if (isRelationOnly(fn2) && shape2.k === "arr") {
+      const d = instantiateReturn(fn2, [acc, shape2.element]);
       return joinAbs(acc, d);
     }
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       if (noInitial) {
-        const firstIdx = shape.elements.findIndex((_, i) => !isHole(i));
+        const firstIdx = shape2.elements.findIndex((_, i) => !isHole(i));
         if (firstIdx === -1) throw new NudoThrow(errorTypeAbs("TypeError"));
-        let acc2 = shape.elements[firstIdx];
-        for (let i = firstIdx + 1; i < shape.elements.length; i++) {
+        let acc2 = shape2.elements[firstIdx];
+        for (let i = firstIdx + 1; i < shape2.elements.length; i++) {
           if (isHole(i)) continue;
-          acc2 = callFn(fn, acc2, shape.elements[i], $lit(i), arr);
+          acc2 = callFn(fn2, acc2, shape2.elements[i], $lit(i), arr);
         }
         return acc2;
       }
-      for (let i = 0; i < shape.elements.length; i++) {
+      for (let i = 0; i < shape2.elements.length; i++) {
         if (isHole(i)) continue;
-        acc = callFn(fn, acc, shape.elements[i], $lit(i), arr);
+        acc = callFn(fn2, acc, shape2.elements[i], $lit(i), arr);
       }
       return acc;
     }
-    return callFn(fn, acc, shape.element, unknownIdx(), arr);
+    return callFn(fn2, acc, shape2.element, unknownIdx(), arr);
   }
   if (method === "reduceRight") {
     validateCallableArg(args[0], "reduceRight callback may not be callable");
-    const fn = args[0];
+    const fn2 = args[0];
     const noInitial = args.length < 2;
     let acc = args[1] ?? unknown;
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       if (noInitial) {
         let lastIdx = -1;
-        for (let i = shape.elements.length - 1; i >= 0; i--) {
+        for (let i = shape2.elements.length - 1; i >= 0; i--) {
           if (!isHole(i)) {
             lastIdx = i;
             break;
           }
         }
         if (lastIdx === -1) throw new NudoThrow(errorTypeAbs("TypeError"));
-        let acc2 = shape.elements[lastIdx];
+        let acc2 = shape2.elements[lastIdx];
         for (let i = lastIdx - 1; i >= 0; i--) {
           if (isHole(i)) continue;
-          acc2 = callFn(fn, acc2, shape.elements[i], $lit(i), arr);
+          acc2 = callFn(fn2, acc2, shape2.elements[i], $lit(i), arr);
         }
         return acc2;
       }
-      for (let i = shape.elements.length - 1; i >= 0; i--) {
+      for (let i = shape2.elements.length - 1; i >= 0; i--) {
         if (isHole(i)) continue;
-        acc = callFn(fn, acc, shape.elements[i], $lit(i), arr);
+        acc = callFn(fn2, acc, shape2.elements[i], $lit(i), arr);
       }
       return acc;
     }
@@ -15602,14 +16456,14 @@ function invokeArrMethod(arr, method, args) {
         cause: "reduceRight of possibly-empty array with no initial value"
       });
     }
-    return callFn(fn, acc, shape.element, unknownIdx(), arr);
+    return callFn(fn2, acc, shape2.element, unknownIdx(), arr);
   }
   if (method === "filter") {
     validateCallableArg(args[0], "filter callback may not be callable");
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       const kept = [];
       let anyUncertain = false;
-      shape.elements.forEach((el2, i) => {
+      shape2.elements.forEach((el2, i) => {
         if (isHole(i)) return;
         const p = callFn(args[0], el2, $lit(i), arr);
         const t = callbackTruth(p);
@@ -15641,33 +16495,33 @@ function invokeArrMethod(arr, method, args) {
   }
   if (method === "flatMap") {
     validateCallableArg(args[0], "flatMap callback may not be callable");
-    if (shape.k === "tuple") {
-      const mapped = shape.elements.map(
+    if (shape2.k === "tuple") {
+      const mapped = shape2.elements.map(
         (el, i) => isHole(i) ? abs({ k: "tuple", elements: [] }, void 0, void 0, "exact") : callFn(args[0], el, $lit(i), arr)
       );
       return projectFlatMapResult(arr.conf, mapped);
     }
-    const out = callFn(args[0], shape.element, unknownIdx(), arr);
+    const out = callFn(args[0], shape2.element, unknownIdx(), arr);
     return projectFlatMapResult(arr.conf, [out]);
   }
   if (method === "forEach") {
     validateCallableArg(args[0], "forEach callback may not be callable");
-    if (shape.k === "tuple") {
-      shape.elements.forEach((el, i) => {
+    if (shape2.k === "tuple") {
+      shape2.elements.forEach((el, i) => {
         if (!isHole(i)) callFn(args[0], el, $lit(i), arr);
       });
     } else {
-      callFn(args[0], shape.element, unknownIdx(), arr);
+      callFn(args[0], shape2.element, unknownIdx(), arr);
     }
     return undefAbs();
   }
   if (method === "some" || method === "every") {
     validateCallableArg(args[0], `${method} callback may not be callable`);
     let undecided = false;
-    if (shape.k === "tuple") {
-      for (let i = 0; i < shape.elements.length; i++) {
+    if (shape2.k === "tuple") {
+      for (let i = 0; i < shape2.elements.length; i++) {
         if (isHole(i)) continue;
-        const t = callbackTruth(callFn(args[0], shape.elements[i], $lit(i), arr));
+        const t = callbackTruth(callFn(args[0], shape2.elements[i], $lit(i), arr));
         if (t === void 0) {
           undecided = true;
           continue;
@@ -15676,7 +16530,7 @@ function invokeArrMethod(arr, method, args) {
         if (method === "every" && !t) return boolLit(false);
       }
     } else {
-      const t = callbackTruth(callFn(args[0], shape.element, unknownIdx(), arr));
+      const t = callbackTruth(callFn(args[0], shape2.element, unknownIdx(), arr));
       if (t === void 0) return bool();
       if (method === "some" && t) return boolLit(true);
       if (method === "every" && !t) return boolLit(false);
@@ -15687,21 +16541,21 @@ function invokeArrMethod(arr, method, args) {
   }
   if (method === "find") {
     validateCallableArg(args[0], "find callback may not be callable");
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       let undecided = false;
-      for (let i = 0; i < shape.elements.length; i++) {
-        const el2 = shape.elements[i];
+      for (let i = 0; i < shape2.elements.length; i++) {
+        const el2 = shape2.elements[i];
         const t2 = callbackTruth(callFn(args[0], el2, $lit(i), arr));
         if (t2 === true) return el2;
         if (t2 === void 0) undecided = true;
       }
       if (undecided) {
-        const joined = shape.elements.reduce((a, b) => joinAbs(a, b));
+        const joined = shape2.elements.reduce((a, b) => joinAbs(a, b));
         return joinAbs(joined, undefAbs());
       }
       return undefAbs();
     }
-    const el = shape.element;
+    const el = shape2.element;
     const t = callbackTruth(callFn(args[0], el, unknownIdx(), arr));
     if (t === true) return el;
     if (t === false) return undefAbs();
@@ -15709,17 +16563,17 @@ function invokeArrMethod(arr, method, args) {
   }
   if (method === "findIndex") {
     validateCallableArg(args[0], "findIndex callback may not be callable");
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       let undecided = false;
-      for (let i = 0; i < shape.elements.length; i++) {
-        const t2 = callbackTruth(callFn(args[0], shape.elements[i], $lit(i), arr));
+      for (let i = 0; i < shape2.elements.length; i++) {
+        const t2 = callbackTruth(callFn(args[0], shape2.elements[i], $lit(i), arr));
         if (t2 === true) return $lit(i);
         if (t2 === void 0) undecided = true;
       }
       if (undecided) return joinAbs(unknownIdx(), $lit(-1));
       return $lit(-1);
     }
-    const t = callbackTruth(callFn(args[0], shape.element, unknownIdx(), arr));
+    const t = callbackTruth(callFn(args[0], shape2.element, unknownIdx(), arr));
     if (t === true) return unknownIdx();
     if (t === false) return $lit(-1);
     return joinAbs(unknownIdx(), $lit(-1));
@@ -15727,28 +16581,28 @@ function invokeArrMethod(arr, method, args) {
   if (method === "findLast" || method === "findLastIndex") {
     validateCallableArg(args[0], `${method} callback may not be callable`);
     const wantIndex = method === "findLastIndex";
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       let undecided = false;
-      for (let i = shape.elements.length - 1; i >= 0; i--) {
-        const t2 = callbackTruth(callFn(args[0], shape.elements[i], $lit(i), arr));
-        if (t2 === true) return wantIndex ? $lit(i) : shape.elements[i];
+      for (let i = shape2.elements.length - 1; i >= 0; i--) {
+        const t2 = callbackTruth(callFn(args[0], shape2.elements[i], $lit(i), arr));
+        if (t2 === true) return wantIndex ? $lit(i) : shape2.elements[i];
         if (t2 === void 0) undecided = true;
       }
       if (undecided) {
-        const joined = shape.elements.length ? shape.elements.reduce((a, b) => joinAbs(a, b)) : unknown;
+        const joined = shape2.elements.length ? shape2.elements.reduce((a, b) => joinAbs(a, b)) : unknown;
         return wantIndex ? joinAbs(unknownIdx(), $lit(-1)) : joinAbs(joined, undefAbs());
       }
       return wantIndex ? $lit(-1) : undefAbs();
     }
-    const t = callbackTruth(callFn(args[0], shape.element, unknownIdx(), arr));
+    const t = callbackTruth(callFn(args[0], shape2.element, unknownIdx(), arr));
     if (wantIndex) {
       if (t === true) return unknownIdx();
       if (t === false) return $lit(-1);
       return joinAbs(unknownIdx(), $lit(-1));
     }
-    if (t === true) return shape.element;
+    if (t === true) return shape2.element;
     if (t === false) return undefAbs();
-    return joinAbs(shape.element, undefAbs());
+    return joinAbs(shape2.element, undefAbs());
   }
   if (method === "join") {
     const folded = arrayJoinWithSep(arr, args[0]);
@@ -15760,11 +16614,11 @@ function invokeArrMethod(arr, method, args) {
     return arrayJoinToString(arr);
   }
   if (method === "keys") {
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       return abs(
         {
           k: "tuple",
-          elements: shape.elements.map((_, i) => numLit(i))
+          elements: shape2.elements.map((_, i) => numLit(i))
         },
         void 0,
         void 0,
@@ -15774,12 +16628,12 @@ function invokeArrMethod(arr, method, args) {
     return abs({ k: "arr", element: unknownIdx() }, void 0, void 0, "partial");
   }
   if (method === "values") {
-    if (shape.k === "tuple") {
-      const holes2 = shape.holes ?? [];
+    if (shape2.k === "tuple") {
+      const holes2 = shape2.holes ?? [];
       return abs(
         {
           k: "tuple",
-          elements: shape.elements.map((el, i) => holes2.includes(i) ? undefAbs() : el)
+          elements: shape2.elements.map((el, i) => holes2.includes(i) ? undefAbs() : el)
         },
         void 0,
         void 0,
@@ -15789,12 +16643,12 @@ function invokeArrMethod(arr, method, args) {
     return arr;
   }
   if (method === "entries") {
-    if (shape.k === "tuple") {
-      const holes2 = shape.holes ?? [];
+    if (shape2.k === "tuple") {
+      const holes2 = shape2.holes ?? [];
       return abs(
         {
           k: "tuple",
-          elements: shape.elements.map(
+          elements: shape2.elements.map(
             (el, i) => abs(
               { k: "tuple", elements: [numLit(i), holes2.includes(i) ? undefAbs() : el] },
               void 0,
@@ -15812,7 +16666,7 @@ function invokeArrMethod(arr, method, args) {
       {
         k: "arr",
         element: abs(
-          { k: "tuple", elements: [unknownIdx(), shape.element] },
+          { k: "tuple", elements: [unknownIdx(), shape2.element] },
           void 0,
           void 0,
           "partial"
@@ -15824,16 +16678,16 @@ function invokeArrMethod(arr, method, args) {
     );
   }
   if (method === "fill" && args.length >= 1) {
-    return fillTuple(shape, args, arr);
+    return fillTuple(shape2, args, arr);
   }
   if (method === "sort" || method === "toSorted") {
     validateCallableArg(args[0], `${method} comparator may not be callable`, {
       undefinedOk: true
     });
-    if (shape.k === "arr") {
-      return abs({ k: "arr", element: shape.element }, void 0, void 0, "partial");
+    if (shape2.k === "arr") {
+      return abs({ k: "arr", element: shape2.element }, void 0, void 0, "partial");
     }
-    const slots = shape.elements.map((el2, i) => isHole(i) ? undefAbs() : el2);
+    const slots = shape2.elements.map((el2, i) => isHole(i) ? undefAbs() : el2);
     const isUndefLit = (el2) => el2.term?.op === "lit" && el2.term.value === void 0;
     const isDefaultCmp = args[0] === void 0 || !!asAbs(args[0])?.term && asAbs(args[0]).term.op === "lit" && asAbs(args[0]).term.value === void 0;
     if (isDefaultCmp) {
@@ -15862,17 +16716,17 @@ function invokeArrMethod(arr, method, args) {
         }
       }
     }
-    const el = shape.elements.length ? shape.elements.reduce((x, y) => joinAbs(x, y)) : unknown;
+    const el = shape2.elements.length ? shape2.elements.reduce((x, y) => joinAbs(x, y)) : unknown;
     return abs({ k: "arr", element: el }, void 0, void 0, confJoin(arr.conf, "path"));
   }
   if (method === "reverse") {
-    if (shape.k === "tuple") {
-      const len = shape.elements.length;
-      const holesR = shape.holes ? shape.holes.map((h) => len - 1 - h) : void 0;
+    if (shape2.k === "tuple") {
+      const len = shape2.elements.length;
+      const holesR = shape2.holes ? shape2.holes.map((h) => len - 1 - h) : void 0;
       return abs(
         {
           k: "tuple",
-          elements: [...shape.elements].reverse(),
+          elements: [...shape2.elements].reverse(),
           holes: holesR && holesR.length > 0 ? holesR : void 0
         },
         void 0,
@@ -15880,21 +16734,21 @@ function invokeArrMethod(arr, method, args) {
         confJoin(arr.conf, "path")
       );
     }
-    return abs({ k: "arr", element: shape.element }, void 0, void 0, "partial");
+    return abs({ k: "arr", element: shape2.element }, void 0, void 0, "partial");
   }
   if (method === "toReversed") {
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       return abs(
         {
           k: "tuple",
-          elements: [...shape.elements].reverse().map((el, i) => (shape.holes ?? []).includes(shape.elements.length - 1 - i) ? undefAbs() : el)
+          elements: [...shape2.elements].reverse().map((el, i) => (shape2.holes ?? []).includes(shape2.elements.length - 1 - i) ? undefAbs() : el)
         },
         void 0,
         void 0,
         confJoin(arr.conf, "path")
       );
     }
-    return abs({ k: "arr", element: shape.element }, void 0, void 0, "partial");
+    return abs({ k: "arr", element: shape2.element }, void 0, void 0, "partial");
   }
   if (method === "flat") {
     validateIndexArg(args[0], "flat depth may not be convertible to a number");
@@ -15922,10 +16776,10 @@ function invokeArrMethod(arr, method, args) {
       }
       return { els: out, degraded };
     };
-    if (shape.k === "arr") {
-      const es = shape.element.shape;
+    if (shape2.k === "arr") {
+      const es = shape2.element.shape;
       const innerEls = es.k === "tuple" ? es.elements.length ? es.elements.reduce((x, y) => joinAbs(x, y)) : unknown : es.k === "arr" ? es.element : void 0;
-      const el = innerEls !== void 0 ? joinAbs(shape.element, innerEls) : shape.element;
+      const el = innerEls !== void 0 ? joinAbs(shape2.element, innerEls) : shape2.element;
       return abs({ k: "arr", element: el }, void 0, void 0, "partial");
     }
     if (depthRaw === null) {
@@ -15933,8 +16787,8 @@ function invokeArrMethod(arr, method, args) {
         kind: "TypeError",
         cause: "flat depth may not be convertible to a number"
       });
-      const shallow = rec(shape.elements, holeSet, 0);
-      const deep = rec(shape.elements, holeSet, Number.MAX_SAFE_INTEGER);
+      const shallow = rec(shape2.elements, holeSet, 0);
+      const deep = rec(shape2.elements, holeSet, Number.MAX_SAFE_INTEGER);
       if (shallow !== null && deep !== null) {
         const el = [...shallow.els, ...deep.els].reduce((x, y) => joinAbs(x, y));
         return abs({ k: "arr", element: el }, void 0, void 0, "partial");
@@ -15942,9 +16796,9 @@ function invokeArrMethod(arr, method, args) {
       return unknown;
     }
     const depth = depthRaw === void 0 ? 1 : Math.max(depthRaw, 0);
-    const r = rec(shape.elements, holeSet, depth);
+    const r = rec(shape2.elements, holeSet, depth);
     if (r === null) {
-      const shallow = rec(shape.elements, holeSet, 0);
+      const shallow = rec(shape2.elements, holeSet, 0);
       const el = shallow && shallow.els.length ? shallow.els.reduce((x, y) => joinAbs(x, y)) : unknown;
       return abs({ k: "arr", element: el }, void 0, void 0, "partial");
     }
@@ -15963,22 +16817,22 @@ function invokeArrMethod(arr, method, args) {
     validateIndexArg(args[0], "toSpliced start may not be convertible to a number");
     validateIndexArg(args[1], "toSpliced skipCount may not be convertible to a number");
     const items = args.slice(2);
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       const st = toIOI(args[0]);
       const dc = args[1] === void 0 ? void 0 : toIOI(args[1]);
       if (st === null || dc === null) {
-        const parts2 = [...shape.elements.filter((_, i) => !isHole(i)), ...items];
+        const parts2 = [...shape2.elements.filter((_, i) => !isHole(i)), ...items];
         const el = parts2.length ? parts2.reduce((x, y) => joinAbs(x, y)) : unknown;
         return abs({ k: "arr", element: el }, void 0, void 0, "partial");
       }
-      const len = shape.elements.length;
+      const len = shape2.elements.length;
       const a = st === void 0 ? 0 : st < 0 ? Math.max(len + st, 0) : Math.min(st, len);
       const skip = dc === void 0 ? len - a : Math.max(0, Math.min(dc, len - a));
       const solid = (el, i) => isHole(i) ? undefAbs() : el;
       const els = [
-        ...shape.elements.slice(0, a).map(solid),
+        ...shape2.elements.slice(0, a).map(solid),
         ...items,
-        ...shape.elements.slice(a + skip).map((el, i) => solid(el, a + skip + i))
+        ...shape2.elements.slice(a + skip).map((el, i) => solid(el, a + skip + i))
       ];
       return abs(
         { k: "tuple", elements: els },
@@ -15987,7 +16841,7 @@ function invokeArrMethod(arr, method, args) {
         confJoin(arr.conf, "path")
       );
     }
-    const parts = [shape.element, ...items];
+    const parts = [shape2.element, ...items];
     return abs(
       { k: "arr", element: parts.reduce((x, y) => joinAbs(x, y)) },
       void 0,
@@ -15998,21 +16852,21 @@ function invokeArrMethod(arr, method, args) {
   if (method === "with") {
     validateIndexArg(args[0], "with index may not be convertible to a number");
     const v2 = args[1] ?? undefAbs();
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       const iv = toIOI(args[0]) ?? 0;
       if (iv === null) {
         recordMayThrow({ kind: "RangeError", cause: "with index may be out of range" });
         return abs(
-          { k: "tuple", elements: shape.elements.map((el) => joinAbs(el, v2)) },
+          { k: "tuple", elements: shape2.elements.map((el) => joinAbs(el, v2)) },
           void 0,
           void 0,
           "partial"
         );
       }
-      const len = shape.elements.length;
+      const len = shape2.elements.length;
       const idx = iv < 0 ? len + iv : iv;
       if (idx < 0 || idx >= len) throw new NudoThrow(errorTypeAbs("RangeError"));
-      const els = shape.elements.map(
+      const els = shape2.elements.map(
         (el, i) => i === idx ? v2 : isHole(i) ? undefAbs() : el
       );
       return abs(
@@ -16023,15 +16877,15 @@ function invokeArrMethod(arr, method, args) {
       );
     }
     return abs(
-      { k: "arr", element: joinAbs(shape.element, v2) },
+      { k: "arr", element: joinAbs(shape2.element, v2) },
       void 0,
       void 0,
       "partial"
     );
   }
   if (method === "concat") {
-    if (shape.k === "tuple") {
-      const out = [...shape.elements];
+    if (shape2.k === "tuple") {
+      const out = [...shape2.elements];
       const holesC = new Set(holes);
       let degraded = false;
       for (const a of args) {
@@ -16064,7 +16918,7 @@ function invokeArrMethod(arr, method, args) {
         confJoin(arr.conf, "path")
       );
     }
-    const parts = [shape.element, ...args.map((a) => {
+    const parts = [shape2.element, ...args.map((a) => {
       const aa = asAbs(a) ?? unknown;
       return aa.shape.k === "arr" || aa.shape.k === "tuple" ? aa.shape.k === "arr" ? aa.shape.element : aa.shape.elements.length ? aa.shape.elements.reduce((x, y) => joinAbs(x, y)) : unknown : aa;
     })];
@@ -16078,24 +16932,24 @@ function invokeArrMethod(arr, method, args) {
   if (method === "slice") {
     validateIndexArg(args[0], "slice start may not be convertible to a number");
     validateIndexArg(args[1], "slice end may not be convertible to a number");
-    if (shape.k === "tuple") {
+    if (shape2.k === "tuple") {
       const st = toIOI(args[0]);
       const en = toIOI(args[1]);
       if (st === null || en === null) {
-        const el = shape.elements.length ? shape.elements.reduce((x, y) => joinAbs(x, y)) : unknown;
+        const el = shape2.elements.length ? shape2.elements.reduce((x, y) => joinAbs(x, y)) : unknown;
         return abs({ k: "arr", element: el }, void 0, void 0, "partial");
       }
-      const len = shape.elements.length;
+      const len = shape2.elements.length;
       const s = st === void 0 ? 0 : st < 0 ? Math.max(len + st, 0) : Math.min(st, len);
       const e = en === void 0 ? len : en < 0 ? Math.max(len + en, 0) : Math.min(en, len);
       if (e <= s) {
         return abs({ k: "tuple", elements: [] }, void 0, void 0, confJoin(arr.conf, "exact"));
       }
-      const holesS = (shape.holes ?? []).filter((h) => h >= s && h < e).map((h) => h - s);
+      const holesS = (shape2.holes ?? []).filter((h) => h >= s && h < e).map((h) => h - s);
       return abs(
         {
           k: "tuple",
-          elements: shape.elements.slice(s, e),
+          elements: shape2.elements.slice(s, e),
           holes: holesS.length > 0 ? holesS : void 0
         },
         void 0,
@@ -16103,12 +16957,12 @@ function invokeArrMethod(arr, method, args) {
         confJoin(arr.conf, "path")
       );
     }
-    return abs({ k: "arr", element: shape.element }, void 0, void 0, "partial");
+    return abs({ k: "arr", element: shape2.element }, void 0, void 0, "partial");
   }
   if (method === "indexOf" || method === "lastIndexOf") {
     validateIndexArg(args[1], `${method} fromIndex may not be convertible to a number`);
-    if (shape.k === "tuple") {
-      const els = shape.elements;
+    if (shape2.k === "tuple") {
+      const els = shape2.elements;
       const search = args[0];
       const searchLit = search !== void 0 && search.term?.op === "lit" ? litValue(search) : void 0;
       const hasLitSearch = search !== void 0 && search.term?.op === "lit";
@@ -16153,22 +17007,22 @@ function invokeArrMethod(arr, method, args) {
     return abs({ k: "prim", type: "number" }, void 0, void 0, "path");
   }
   if (method === "pop") {
-    if (shape.k === "tuple") {
-      return shape.elements.length > 0 ? shape.elements[shape.elements.length - 1] ?? unknown : undefAbs();
+    if (shape2.k === "tuple") {
+      return shape2.elements.length > 0 ? shape2.elements[shape2.elements.length - 1] ?? unknown : undefAbs();
     }
-    if (shape.k === "arr") return joinAbs(shape.element, undefAbs());
+    if (shape2.k === "arr") return joinAbs(shape2.element, undefAbs());
   }
   if (method === "shift") {
-    if (shape.k === "tuple" && shape.elements.length > 0) {
-      return shape.elements[0] ?? unknown;
+    if (shape2.k === "tuple" && shape2.elements.length > 0) {
+      return shape2.elements[0] ?? unknown;
     }
-    if (shape.k === "arr") return joinAbs(shape.element, undefAbs());
+    if (shape2.k === "arr") return joinAbs(shape2.element, undefAbs());
   }
   if (method === "at") {
     validateIndexArg(args[0], "at index may not be convertible to a number");
     const iv = toIntegerOrInfinityLit(args[0]);
-    if (shape.k === "tuple") {
-      const els = shape.elements;
+    if (shape2.k === "tuple") {
+      const els = shape2.elements;
       if (iv === void 0) {
         if (els.length === 0) return undefAbs();
         return joinAbs(els.reduce((a, b) => joinAbs(a, b)), undefAbs());
@@ -16177,7 +17031,7 @@ function invokeArrMethod(arr, method, args) {
       if (idx >= 0 && idx < els.length) return els[idx] ?? unknown;
       return undefAbs();
     }
-    if (shape.k === "arr") return joinAbs(shape.element, undefAbs());
+    if (shape2.k === "arr") return joinAbs(shape2.element, undefAbs());
   }
   return void 0;
 }
@@ -16391,11 +17245,11 @@ function $setKey(o, key, value) {
       confJoin("path", value.conf)
     );
   }
-  const shape = o.shape;
-  const prevIndex = shape.index?.value;
+  const shape2 = o.shape;
+  const prevIndex = shape2.index?.value;
   const indexVal = prevIndex ? joinAbs(prevIndex, val) : val;
-  const next = objOf({ ...shape.slots }, {
-    index: { key: shape.index?.key ?? unknown, value: indexVal },
+  const next = objOf({ ...shape2.slots }, {
+    index: { key: shape2.index?.key ?? unknown, value: indexVal },
     open: true
   });
   next.conf = confJoin(o.conf, value.conf);
@@ -17403,12 +18257,12 @@ ${js}`;
   }
   const cjsMerge = hasCjsExports ? `(() => { const me = $get(module, "exports"); if (me !== __nudoCjsOrig && me && typeof me === "object" && "shape" in me) { return { default: me }; } const out = {}; if (__nudoCjsOrig && __nudoCjsOrig.shape && __nudoCjsOrig.shape.k === "obj") { for (const k of Object.keys(__nudoCjsOrig.shape.slots)) out[k] = __nudoCjsOrig.shape.slots[k].value; } return out; })()` : "{}";
   const ret = `return { ...__nudoExports, ...${cjsMerge}, ${names.join(", ")} };`;
-  const fn = new Function(...argNames, `${js}
+  const fn2 = new Function(...argNames, `${js}
 ${ret}`);
   setEvalBindingSink(bindings);
   beginClassEpoch();
   try {
-    const result = fn(...args);
+    const result = fn2(...args);
     runBindings.set(result, bindings);
     return result;
   } finally {
@@ -17500,14 +18354,14 @@ function callTranspiledExportFull(exports, name, args, opts) {
   });
 }
 function callTranspiledExportFullInner(exports, name, args, opts) {
-  const fn = Object.hasOwn(exports, name) ? exports[name] : void 0;
-  if (typeof fn === "function") {
+  const fn2 = Object.hasOwn(exports, name) ? exports[name] : void 0;
+  if (typeof fn2 === "function") {
     const callArgs = args.map(
       (a) => a && typeof a === "object" && "shape" in a ? $copy(a) : asAbsVal(a)
     );
     return runWithLoopExits(() => {
       try {
-        const invoke = () => withNewTargetReset(() => fn(...callArgs));
+        const invoke = () => withNewTargetReset(() => fn2(...callArgs));
         const r = opts?.phi ? withExecPhi(opts.phi, invoke) : invoke();
         drainPromiseMicros();
         if (!isAbsVal(r)) return joinControlExits(unknown);
@@ -17536,11 +18390,11 @@ function callTranspiledExportFullInner(exports, name, args, opts) {
       }
     });
   }
-  if (isAbsVal(fn)) {
-    if (fn.shape.k === "fn") {
+  if (isAbsVal(fn2)) {
+    if (fn2.shape.k === "fn") {
       return runWithLoopExits(() => {
         try {
-          const r = $call(fn, args);
+          const r = $call(fn2, args);
           drainPromiseMicros();
           return joinControlExits(r);
         } catch (e) {
@@ -17560,7 +18414,7 @@ function callTranspiledExportFullInner(exports, name, args, opts) {
       });
     }
     drainPromiseMicros();
-    return { result: fn, throws: never };
+    return { result: fn2, throws: never };
   }
   drainPromiseMicros();
   return { result: unknown, throws: never };
@@ -17744,26 +18598,31 @@ function joinThrowsSince2(mark) {
   if (items.length === 1) return items[0];
   return items.reduce((a, b) => joinAbs(a, b));
 }
-function $call(fn, args, thisVal) {
-  return withNewTargetReset(() => $callInner(fn, args, thisVal));
+function $call(fn2, args, thisVal) {
+  return withNewTargetReset(() => $callInner(fn2, args, thisVal));
 }
-function $callInner(fn, args, thisVal) {
-  if (fn?.shape?.k === "sum") {
-    const results = fn.shape.members.map((m) => $call(m, args, thisVal));
-    if (results.every((r) => r.shape.k === "unknown")) return unknown;
+function $callInner(fn2, args, thisVal) {
+  if (fn2?.shape?.k === "sum") {
+    const results = fn2.shape.members.map((m) => $call(m, args, thisVal));
+    if (results.every((r2) => r2.shape.k === "unknown")) return unknown;
     return results.reduce((a, b) => joinAbs(a, b));
   }
-  const pureName = pureFnNameOf(fn);
-  const fnObj = fn && typeof fn === "object" ? fn : void 0;
+  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;
   if (fnObj && pk !== void 0) {
     const hit = pureMemo.get(fnObj)?.get(pk);
     if (hit !== void 0) return routeApplyThrows(hit.abs, hit.throws);
   }
-  const impl = getFnImpl(fn);
+  const impl = getFnImpl(fn2);
   if (!impl?.body && !impl?.apply) {
-    if (impl?.relation || isRelFn(fn)) return instantiateReturn(fn, args);
-    const calleeAbs = fn && typeof fn === "object" ? fn : void 0;
+    if (impl?.relation || isRelFn(fn2)) return instantiateReturn(fn2, args);
+    const calleeAbs = fn2 && typeof fn2 === "object" ? fn2 : void 0;
     const calleeK = calleeAbs?.shape?.k;
     if (calleeK === "prim" || calleeAbs !== void 0 && isNullishLitAbs(calleeAbs)) {
       throw new NudoThrow(errorTypeAbs("TypeError"));
@@ -17777,8 +18636,8 @@ function $callInner(fn, args, thisVal) {
     return unknown;
   }
   if (impl?.apply) {
-    const key = callBudgetKey("absfn", impl.fingerprint ?? stableCallId(fn), args);
-    const label = fn.shape.name ?? "anonymous";
+    const key = callBudgetKey("absfn", impl.fingerprint ?? stableCallId(fn2), args);
+    const label = fn2.shape.name ?? "anonymous";
     if (!enterCall(key, label)) return truncatedAbs();
     try {
       try {
@@ -17804,8 +18663,8 @@ function $callInner(fn, args, thisVal) {
   }
   const compiled = compiledBodyOf(impl);
   if (compiled) {
-    const key = callBudgetKey("absbody", impl.fingerprint ?? stableCallId(fn), args);
-    const label = fn.shape.name ?? "anonymous";
+    const key = callBudgetKey("absbody", impl.fingerprint ?? stableCallId(fn2), args);
+    const label = fn2.shape.name ?? "anonymous";
     if (!enterCall(key, label)) return truncatedAbs();
     try {
       const throwMark = throwExitsMark();
@@ -18182,9 +19041,9 @@ function evalObjectMethod(name, args) {
       const key = keyR?.ok ? keyR.value : void 0;
       if (typeof key !== "string") return boolPrim();
       if (a0.shape.k === "obj") {
-        const shape = a0.shape;
-        if (Object.prototype.hasOwnProperty.call(shape.slots, key)) return boolLit(true);
-        if (!shape.open && a0.conf === "exact") return boolLit(false);
+        const shape2 = a0.shape;
+        if (Object.prototype.hasOwnProperty.call(shape2.slots, key)) return boolLit(true);
+        if (!shape2.open && a0.conf === "exact") return boolLit(false);
         return boolPrim();
       }
       return boolPrim();
@@ -21404,6 +22263,40 @@ export {
   $removeMemberNullish,
   $narrowTypeOf,
   $nullishTest,
+  SELF,
+  getTerm,
+  lenTerm,
+  isNudoConstraint,
+  isIntFlag,
+  number,
+  string,
+  boolean,
+  any,
+  array,
+  shape,
+  litC,
+  union,
+  nullable,
+  lazy,
+  derefConstraint,
+  constraintAdmitsNullish,
+  fn,
+  andC,
+  partial,
+  pick,
+  omit,
+  CONSTRAINT_BUILDERS,
+  CONSTRAINT_BUILDER_NAMES,
+  CONSTRAINT_EXPR_RE,
+  instantiateConstraint,
+  instantiateOnTerm,
+  constraintToEntryAbs,
+  fnConstraintToEntryReqs,
+  throwConstraintToKinds,
+  literalMeetsConstraint,
+  attachContractFaces,
+  setContractFaceResolver,
+  contractFacesFromEffectiveInterface,
   clearPureCallMemo,
   setEvalAssignCollector,
   $assignRecord,