@nudojs/core 0.3.1 → 1.0.0

package/dist/{chunk-BU4A6XJ3.js → chunk-RZOQL6PT.js}

@@ -39,6 +39,7 @@ __export(runtime_exports, {
   $neg: () => $neg,
   $not: () => $not,
   $obj: () => $obj,
+  $regex: () => $regex,
   $set: () => $set,
   $spread: () => $spread,
   $sub: () => $sub,
@@ -55,6 +56,8 @@ __export(runtime_exports, {
   isDefinitelyFalse: () => isDefinitelyFalse,
   isDefinitelyTrue: () => isDefinitelyTrue,
   isNudoThrow: () => isNudoThrow,
+  litTruth: () => litTruth,
+  namespaceNameOf: () => namespaceNameOf,
   withExecPhi: () => withExecPhi
 });
 
@@ -700,6 +703,86 @@ function shapeOnlyFn(paramTypes, returnType, opts) {
 }
 
 // src/algebra/template.ts
+function viewTemplateParts(parts, describe) {
+  return parts.map((p) => {
+    const d = describe(p);
+    return "fixed" in d ? { fixed: d.fixed, render: d.fixed, part: p } : { fixed: void 0, render: d.render, part: p };
+  });
+}
+function knownPrefixOfViews(views) {
+  let s = "";
+  for (const v2 of views) {
+    if (v2.fixed !== void 0) s += v2.fixed;
+    else break;
+  }
+  return s;
+}
+function knownSuffixOfViews(views) {
+  let s = "";
+  for (let i = views.length - 1; i >= 0; i--) {
+    const v2 = views[i];
+    if (v2.fixed !== void 0) s = v2.fixed + s;
+    else break;
+  }
+  return s;
+}
+function allFixedTextOfViews(views) {
+  return views.filter((v2) => v2.fixed !== void 0).map((v2) => v2.fixed).join("");
+}
+function fixedLengthOfViews(views) {
+  if (views.some((v2) => v2.fixed === void 0)) return void 0;
+  return allFixedTextOfViews(views).length;
+}
+function formatTemplateNameViews(views) {
+  const inner = views.map((v2) => v2.fixed !== void 0 ? v2.fixed : `\${${v2.render}}`).join("");
+  return `\`${inner}\``;
+}
+function mergeAdjacentFixedViews(views, rebuildFixed) {
+  const out = [];
+  for (const v2 of views) {
+    const last = out[out.length - 1];
+    if (last && last.fixed !== void 0 && v2.fixed !== void 0) {
+      out[out.length - 1] = rebuildFixed(last.fixed + v2.fixed);
+    } else {
+      out.push(v2);
+    }
+  }
+  return out;
+}
+function templateMatchesValue(value, views) {
+  let pos = 0;
+  for (let i = 0; i < views.length; i++) {
+    const v2 = views[i];
+    if (v2.fixed !== void 0) {
+      if (!value.startsWith(v2.fixed, pos)) return false;
+      pos += v2.fixed.length;
+    } else {
+      if (i === views.length - 1) return true;
+      const next = views[i + 1];
+      if (next?.fixed !== void 0) {
+        const idx = value.indexOf(next.fixed, pos);
+        if (idx === -1) return false;
+        pos = idx;
+      } else {
+        return true;
+      }
+    }
+  }
+  return pos === value.length;
+}
+function decideStartsWith(prefix, search) {
+  if (prefix.length >= search.length) return prefix.startsWith(search);
+  if (search.startsWith(prefix)) return "unknown";
+  return false;
+}
+function decideEndsWith(suffix, search) {
+  if (suffix.length >= search.length) return suffix.endsWith(search);
+  if (search.endsWith(suffix)) return "unknown";
+  return false;
+}
+function decideIncludes(fixedText, search) {
+  return fixedText.includes(search) ? true : "unknown";
+}
 function isStrLit(a) {
   return a.shape.k === "prim" && a.shape.type === "string" && a.term?.op === "lit" && typeof a.term.value === "string";
 }
@@ -709,6 +792,13 @@ function isStrPrim2(a) {
 function isTemplateAbs(a) {
   return a.shape.k === "prim" && a.shape.type === "string" && !!a.pred && a.pred.name?.startsWith("`") === true && Array.isArray(a.pred.meta?.templateParts);
 }
+function describeAbsPart(p) {
+  if (isStrLit(p)) return { fixed: String(litValue(p)) };
+  return { render: p.term ? termToString(p.term) : "string" };
+}
+function absTemplateViews(parts) {
+  return viewTemplateParts(parts, describeAbsPart);
+}
 function templatePartsOf(a) {
   if (isTemplateAbs(a)) {
     const meta = a.pred.meta;
@@ -716,29 +806,18 @@ function templatePartsOf(a) {
   }
   return [a];
 }
+function rebuildAbsFixedView(text) {
+  return {
+    fixed: text,
+    render: text,
+    part: abs({ k: "prim", type: "string" }, lit(text), void 0, "exact")
+  };
+}
 function normalizeParts(parts) {
-  const out = [];
-  for (const p of parts) {
-    const last = out[out.length - 1];
-    if (last && isStrLit(last) && isStrLit(p)) {
-      out[out.length - 1] = abs(
-        { k: "prim", type: "string" },
-        lit(String(litValue(last)) + String(litValue(p))),
-        void 0,
-        "exact"
-      );
-    } else {
-      out.push(p);
-    }
-  }
-  return out;
+  return mergeAdjacentFixedViews(absTemplateViews(parts), rebuildAbsFixedView).map((v2) => v2.part);
 }
 function formatTemplateName(parts) {
-  const inner = parts.map((p) => {
-    if (isStrLit(p)) return String(litValue(p));
-    return `\${${p.term ? termToString(p.term) : "string"}}`;
-  }).join("");
-  return `\`${inner}\``;
+  return formatTemplateNameViews(absTemplateViews(parts));
 }
 function createTemplateAbs(parts) {
   const normalized = normalizeParts(parts);
@@ -790,6 +869,157 @@ function coerceToStringParts(a) {
   return void 0;
 }
 
+// src/algebra/objects.ts
+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" };
+}
+function isObj(a) {
+  return a.shape.k === "obj";
+}
+function getSlot(slots, key) {
+  return Object.prototype.hasOwnProperty.call(slots, key) ? slots[key] : void 0;
+}
+function spread(base, over) {
+  if (!isObj(base) && !isObj(over)) {
+    if (isObj(over)) return { shape: { ...over.shape, open: true }, conf: confJoin(base.conf, over.conf) };
+    if (isObj(base)) return { shape: { ...base.shape, open: true }, conf: confJoin(base.conf, over.conf) };
+    return unknown;
+  }
+  if (!isObj(over)) {
+    if (!isObj(base)) return unknown;
+    return {
+      shape: { ...base.shape, open: true },
+      conf: confJoin(base.conf, "partial")
+    };
+  }
+  if (!isObj(base)) {
+    return { shape: { ...over.shape, open: true }, conf: confJoin(base.conf, over.conf) };
+  }
+  const slots = { ...base.shape.slots };
+  for (const [k, s] of Object.entries(over.shape.slots)) {
+    slots[k] = s;
+  }
+  const open = base.shape.open || over.shape.open || false;
+  const shape = { k: "obj", slots };
+  if (open) shape.open = true;
+  if (base.shape.index || over.shape.index) {
+    shape.index = over.shape.index ?? base.shape.index;
+  }
+  return { shape, conf: confJoin(base.conf, over.conf) };
+}
+function joinObjects(a, b) {
+  if (a.shape.k === "never") return b;
+  if (b.shape.k === "never") return a;
+  if (!isObj(a) || !isObj(b)) {
+    return makeSum(a, b);
+  }
+  const ka = Object.keys(a.shape.slots).sort();
+  const kb = Object.keys(b.shape.slots).sort();
+  const sameKeys = ka.length === kb.length && ka.every((k, i) => k === kb[i]);
+  if (!sameKeys) {
+    return makeSum(a, b);
+  }
+  const slots = {};
+  let conf = confJoin(a.conf, b.conf);
+  for (const k of ka) {
+    const sa = a.shape.slots[k];
+    const sb = b.shape.slots[k];
+    const optional = sa.optional || sb.optional;
+    const jv = joinValues(sa.value, sb.value);
+    conf = confJoin(conf, jv.conf);
+    slots[k] = { value: jv, optional };
+  }
+  return { shape: { k: "obj", slots }, conf };
+}
+function joinValues(a, b) {
+  if (a.shape.k === "never") return b;
+  if (b.shape.k === "never") return a;
+  const va = litValue(a);
+  const vb = litValue(b);
+  if (va !== void 0 && Object.is(va, vb)) return a;
+  if (a.shape.k === "prim" && b.shape.k === "prim" && a.shape.type === b.shape.type) {
+    if (va !== void 0 && vb !== void 0) {
+      return abs(
+        a.shape,
+        void 0,
+        void 0,
+        confJoin(a.conf, "path")
+      );
+    }
+    return abs(a.shape, void 0, void 0, confJoin(confJoin(a.conf, b.conf), "path"));
+  }
+  return makeSum(a, b);
+}
+function makeSum(a, b) {
+  const members = flattenSum([a, b]);
+  if (members.length === 1) return members[0];
+  return {
+    shape: { k: "sum", members },
+    conf: confJoin(a.conf, b.conf)
+  };
+}
+function flattenSum(xs) {
+  const out = [];
+  for (const x of xs) {
+    if (x.shape.k === "sum") out.push(...x.shape.members);
+    else out.push(x);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const x of out) {
+    const key = shapeKey(x);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(x);
+  }
+  return deduped;
+}
+function shapeKey(a) {
+  const s = a.shape;
+  if (s.k === "prim") {
+    const lv = litValue(a);
+    if (lv !== void 0) return `prim:${s.type}:${String(lv)}`;
+    const t = a.term ? termToString(a.term) : "";
+    const p = a.pred && a.pred.op !== "true" ? predToString(a.pred) : "";
+    return `prim:${s.type}:${t}:${p}`;
+  }
+  if (s.k === "never") return "never";
+  if (s.k === "any") return "any";
+  if (s.k === "unknown") return "unknown";
+  if (s.k === "obj") return `obj:${Object.keys(s.slots).sort().join(",")}`;
+  if (s.k === "fn") return `fn:${s.params.length}`;
+  if (s.k === "sum") return `sum:${s.members.length}`;
+  return "other";
+}
+function fnOf(params, name) {
+  const shape = { k: "fn", params };
+  if (name) shape.name = name;
+  return { shape, conf: "exact" };
+}
+function joinFunctions(a, b) {
+  const sa = a.shape;
+  const sb = b.shape;
+  if (sa.k !== "fn" || sb.k !== "fn") return makeSum(a, b);
+  const an = sa.name;
+  const bn = sb.name;
+  if (an && an === bn) {
+    if (sa.params.length === sb.params.length && sa.params.every((p, i) => p === sb.params[i])) {
+      return a;
+    }
+  }
+  return makeSum(a, b);
+}
+function joinAbs(a, b) {
+  if (a.shape.k === "never") return b;
+  if (b.shape.k === "never") return a;
+  if (isObj(a) && isObj(b)) return joinObjects(a, b);
+  if (a.shape.k === "fn" && b.shape.k === "fn") return joinFunctions(a, b);
+  return joinValues(a, b);
+}
+
 // src/algebra/arithmetic.ts
 function add(a, b, phi2 = pTrue) {
   const va = litValue(a);
@@ -873,6 +1103,9 @@ function isAnyLike(a) {
   if (a.shape.k === "unknown") return true;
   return false;
 }
+function coercibleLit(v2) {
+  return v2 !== void 0 && (typeof v2 === "number" || typeof v2 === "string" || typeof v2 === "boolean" || v2 === null);
+}
 function toNumberResult(a, b, op) {
   const term = a.term && b.term ? simplifyTerm(app(op, [a.term, b.term])) : void 0;
   return abs(
@@ -991,6 +1224,9 @@ function sub(a, b, phi2 = pTrue) {
   if (typeof va === "number" && typeof vb === "number") {
     return numLit(va - vb);
   }
+  if (coercibleLit(va) && coercibleLit(vb)) {
+    return numLit(Number(va) - Number(vb));
+  }
   if (isNumericLike(a) && isNumericLike(b) && a.term && b.term) {
     const term = simplifyTerm(app("-", [a.term, b.term]));
     const ab = numericBounds(a, phi2);
@@ -1023,6 +1259,9 @@ function mul(a, b, phi2 = pTrue) {
   if (typeof va === "number" && typeof vb === "number") {
     return numLit(va * vb);
   }
+  if (coercibleLit(va) && coercibleLit(vb)) {
+    return numLit(Number(va) * Number(vb));
+  }
   if (isNumericLike(a) && isNumericLike(b) && a.term && b.term) {
     const term = simplifyTerm(app("*", [a.term, b.term]));
     if (b.term.op === "lit" && b.term.value === 0 || a.term.op === "lit" && a.term.value === 0) {
@@ -1089,6 +1328,9 @@ function div(a, b, phi2 = pTrue) {
     }
     return numLit(va / vb);
   }
+  if (coercibleLit(va) && coercibleLit(vb)) {
+    return numLit(Number(va) / Number(vb));
+  }
   if (isNumericLike(a) && isNumericLike(b) && a.term && b.term) {
     const term = simplifyTerm(app("/", [a.term, b.term]));
     if (b.term.op === "lit" && typeof b.term.value === "number" && b.term.value !== 0) {
@@ -1131,6 +1373,9 @@ function mod(a, b, phi2 = pTrue) {
     }
     return numLit(va % vb);
   }
+  if (coercibleLit(va) && coercibleLit(vb)) {
+    return numLit(Number(va) % Number(vb));
+  }
   if (isNumericLike(a) && isNumericLike(b) && a.term && b.term) {
     const term = simplifyTerm(app("%", [a.term, b.term]));
     if (b.term.op === "lit" && typeof b.term.value === "number" && b.term.value !== 0) {
@@ -1202,6 +1447,20 @@ function compareLits(op, a, b) {
         return a >= b;
     }
   }
+  if (op === "lt" || op === "le" || op === "gt" || op === "ge") {
+    const x = a;
+    const y = b;
+    switch (op) {
+      case "lt":
+        return x < y;
+      case "le":
+        return x <= y;
+      case "gt":
+        return x > y;
+      case "ge":
+        return x >= y;
+    }
+  }
   return void 0;
 }
 function decideByBounds(op, a, b, phi2) {
@@ -1240,6 +1499,34 @@ function trueConstraint(c) {
   if (c.term?.op === "lit" && c.term.value === false) return void 0;
   return c.pred;
 }
+function refineAbsForRelTrue(a, op, k) {
+  const bound = (t) => op === "gt" ? gt(t, lit(k)) : op === "ge" ? ge(t, lit(k)) : op === "lt" ? lt(t, lit(k)) : le(t, lit(k));
+  if (isNumPrim(a) && a.term) {
+    const pred = a.pred && a.pred.op !== "true" ? and(a.pred, bound(a.term)) : bound(a.term);
+    return abs(a.shape, a.term, pred, a.conf);
+  }
+  if (isStrPrim(a)) return a;
+  if ((a.shape.k === "any" || a.shape.k === "unknown") && a.term) {
+    const numArm = abs({ k: "prim", type: "number" }, a.term, bound(a.term), "path");
+    const strArm = abs({ k: "prim", type: "string" }, a.term, void 0, "path");
+    return makeSum(numArm, strArm);
+  }
+  return a;
+}
+function matchRelIdentLit(test) {
+  const t = test;
+  if (t?.type !== "BinaryExpression") return void 0;
+  const rel = t.operator === ">" ? "gt" : t.operator === ">=" ? "ge" : t.operator === "<" ? "lt" : t.operator === "<=" ? "le" : void 0;
+  if (!rel) return void 0;
+  if (t.left?.type === "Identifier" && t.left.name && t.right?.type === "NumericLiteral" && typeof t.right.value === "number") {
+    return { name: t.left.name, op: rel, k: t.right.value };
+  }
+  if (t.right?.type === "Identifier" && t.right.name && t.left?.type === "NumericLiteral" && typeof t.left.value === "number") {
+    const flipped = rel === "gt" ? "lt" : rel === "ge" ? "le" : rel === "lt" ? "gt" : "ge";
+    return { name: t.right.name, op: flipped, k: t.left.value };
+  }
+  return void 0;
+}
 function falseConstraint(c) {
   if (c.term?.op === "lit" && c.term.value === true) return void 0;
   if (c.term?.op === "lit" && c.term.value === false) return pTrue;
@@ -1432,176 +1719,20 @@ function strictEqAbs(a, b) {
   return void 0;
 }
 
-// src/algebra/objects.ts
-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" };
+// src/algebra/containers.ts
+var TUPLE_LITERAL_CAP = 8;
+function shouldWidenArrayLiteral(n) {
+  return n > TUPLE_LITERAL_CAP;
 }
-function isObj(a) {
-  return a.shape.k === "obj";
+function widenedArrayConf() {
+  return "path";
 }
-function spread(base, over) {
-  if (!isObj(base) && !isObj(over)) {
-    if (isObj(over)) return { shape: { ...over.shape, open: true }, conf: confJoin(base.conf, over.conf) };
-    if (isObj(base)) return { shape: { ...base.shape, open: true }, conf: confJoin(base.conf, over.conf) };
-    return unknown;
-  }
-  if (!isObj(over)) {
-    if (!isObj(base)) return unknown;
-    return {
-      shape: { ...base.shape, open: true },
-      conf: confJoin(base.conf, "partial")
-    };
-  }
-  if (!isObj(base)) {
-    return { shape: { ...over.shape, open: true }, conf: confJoin(base.conf, over.conf) };
-  }
-  const slots = { ...base.shape.slots };
-  for (const [k, s] of Object.entries(over.shape.slots)) {
-    slots[k] = s;
-  }
-  const open = base.shape.open || over.shape.open || false;
-  const shape = { k: "obj", slots };
-  if (open) shape.open = true;
-  if (base.shape.index || over.shape.index) {
-    shape.index = over.shape.index ?? base.shape.index;
-  }
-  return { shape, conf: confJoin(base.conf, over.conf) };
-}
-function joinObjects(a, b) {
-  if (a.shape.k === "never") return b;
-  if (b.shape.k === "never") return a;
-  if (!isObj(a) || !isObj(b)) {
-    return makeSum(a, b);
-  }
-  const ka = Object.keys(a.shape.slots).sort();
-  const kb = Object.keys(b.shape.slots).sort();
-  const sameKeys = ka.length === kb.length && ka.every((k, i) => k === kb[i]);
-  if (!sameKeys) {
-    return makeSum(a, b);
-  }
-  const slots = {};
-  let conf = confJoin(a.conf, b.conf);
-  for (const k of ka) {
-    const sa = a.shape.slots[k];
-    const sb = b.shape.slots[k];
-    const optional = sa.optional || sb.optional;
-    const jv = joinValues(sa.value, sb.value);
-    conf = confJoin(conf, jv.conf);
-    slots[k] = { value: jv, optional };
-  }
-  return { shape: { k: "obj", slots }, conf };
-}
-function joinValues(a, b) {
-  if (a.shape.k === "never") return b;
-  if (b.shape.k === "never") return a;
-  const va = litValue(a);
-  const vb = litValue(b);
-  if (va !== void 0 && va === vb) return a;
-  if (a.shape.k === "prim" && b.shape.k === "prim" && a.shape.type === b.shape.type) {
-    if (va !== void 0 && vb !== void 0) {
-      return abs(
-        a.shape,
-        void 0,
-        void 0,
-        confJoin(a.conf, "path")
-      );
-    }
-    return abs(a.shape, void 0, void 0, confJoin(confJoin(a.conf, b.conf), "path"));
-  }
-  return makeSum(a, b);
-}
-function makeSum(a, b) {
-  const members = flattenSum([a, b]);
-  if (members.length === 1) return members[0];
-  return {
-    shape: { k: "sum", members },
-    conf: confJoin(a.conf, b.conf)
-  };
-}
-function flattenSum(xs) {
-  const out = [];
-  for (const x of xs) {
-    if (x.shape.k === "sum") out.push(...x.shape.members);
-    else out.push(x);
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const x of out) {
-    const key = shapeKey(x);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    deduped.push(x);
-  }
-  return deduped;
-}
-function shapeKey(a) {
-  const s = a.shape;
-  if (s.k === "prim") return `prim:${s.type}`;
-  if (s.k === "never") return "never";
-  if (s.k === "any") return "any";
-  if (s.k === "unknown") return "unknown";
-  if (s.k === "obj") return `obj:${Object.keys(s.slots).sort().join(",")}`;
-  if (s.k === "fn") return `fn:${s.params.length}`;
-  if (s.k === "sum") return `sum:${s.members.length}`;
-  return "other";
-}
-function collapseToOptional(sum) {
-  if (sum.shape.k !== "sum") {
-    if (isObj(sum)) return { ...sum, conf: confJoin(sum.conf, "widened") };
-    return sum;
-  }
-  const objs = sum.shape.members.filter(isObj);
-  if (objs.length === 0) {
-    return abs({ k: "unknown" }, void 0, void 0, "widened");
-  }
-  const allKeys = /* @__PURE__ */ new Set();
-  for (const o of objs) {
-    for (const k of Object.keys(o.shape.slots)) allKeys.add(k);
-  }
-  const slots = {};
-  for (const k of allKeys) {
-    const present = objs.filter((o) => k in o.shape.slots);
-    const values = present.map((o) => o.shape.slots[k].value);
-    const joined = values.reduce((acc, v2) => joinValues(acc, v2));
-    const optional = present.length < objs.length;
-    slots[k] = { value: joined, optional };
-  }
-  return { shape: { k: "obj", slots }, conf: "widened" };
-}
-function fnOf(params, name) {
-  const shape = { k: "fn", params };
-  if (name) shape.name = name;
-  return { shape, conf: "exact" };
-}
-function joinFunctions(a, b) {
-  const sa = a.shape;
-  const sb = b.shape;
-  if (sa.k !== "fn" || sb.k !== "fn") return makeSum(a, b);
-  const an = sa.name;
-  const bn = sb.name;
-  if (an && an === bn) {
-    if (sa.params.length === sb.params.length && sa.params.every((p, i) => p === sb.params[i])) {
-      return a;
-    }
-  }
-  return makeSum(a, b);
-}
-function joinAbs(a, b) {
-  if (a.shape.k === "never") return b;
-  if (b.shape.k === "never") return a;
-  if (isObj(a) && isObj(b)) return joinObjects(a, b);
-  if (a.shape.k === "fn" && b.shape.k === "fn") return joinFunctions(a, b);
-  return joinValues(a, b);
-}
-
-// src/algebra/language.ts
-function classesOf(env) {
-  const e = env;
-  if (!e.classes) e.classes = /* @__PURE__ */ new Map();
-  return e.classes;
+
+// src/algebra/language.ts
+function classesOf(env) {
+  const e = env;
+  if (!e.classes) e.classes = /* @__PURE__ */ new Map();
+  return e.classes;
 }
 function defineClass(env, def) {
   classesOf(env).set(def.name, def);
@@ -1710,8 +1841,8 @@ function litFalse() {
 function projectBrand(self, key) {
   if (self.shape.k !== "brand") return unknown;
   const inner = self.shape.shape;
-  if (inner.shape.k === "obj") {
-    const slot = inner.shape.slots[key];
+  if (inner && inner.shape.k === "obj") {
+    const slot = getSlot(inner.shape.slots, key);
     if (slot) return slot.value;
   }
   return unknown;
@@ -1900,7 +2031,7 @@ function leqShape(src, tgt, phi2, env, depth) {
     const srcObj = s.k === "obj" ? s : s.k === "brand" ? s.shape.shape.k === "obj" ? s.shape.shape : null : null;
     if (!srcObj || srcObj.k !== "obj") return fail(`shape ${s.k} \u22AD obj`);
     for (const [key, slot] of Object.entries(t.slots)) {
-      const srcSlot = srcObj.slots[key];
+      const srcSlot = getSlot(srcObj.slots, key);
       if (!srcSlot) {
         if (slot.optional) continue;
         return fail(`missing slot ${key}`);
@@ -1981,1118 +2112,1138 @@ function primOf(a) {
   return void 0;
 }
 
-// src/algebra/exec/calls.ts
-var calls_exports = {};
-__export(calls_exports, {
-  $callNamed: () => $callNamed,
-  getAbsOrigin: () => getAbsOrigin,
-  getBCallCollector: () => getBCallCollector,
-  noteMemberDispatchMiss: () => noteMemberDispatchMiss,
-  notePrimMemberMissing: () => notePrimMemberMissing,
-  noteUnknownMemberMissing: () => noteUnknownMemberMissing,
-  recordMemberDiag: () => recordMemberDiag,
-  setBCallCollector: () => setBCallCollector,
-  setMemberDiagCollector: () => setMemberDiagCollector,
-  tagAbsOrigin: () => tagAbsOrigin
-});
-
-// src/algebra/parse-source.ts
-import { parse as babelParse } from "@babel/parser";
-
-// src/strip-types.ts
-var REMOVE = Symbol("nudo.strip.remove");
-var SKIP_KEYS = /* @__PURE__ */ new Set([
-  "loc",
-  "start",
-  "end",
-  "range",
-  "leadingComments",
-  "trailingComments",
-  "innerComments",
-  "comments",
-  "tokens",
-  "extra"
-]);
-function transformValue(value) {
-  if (Array.isArray(value)) {
-    let changed = false;
-    const out = [];
-    for (const el of value) {
-      if (el === null || el === void 0) {
-        out.push(el);
-        continue;
+// src/algebra/builtins.ts
+function numPrim(conf = "path") {
+  return abs({ k: "prim", type: "number" }, void 0, void 0, conf);
+}
+function strPrim(conf = "path") {
+  return abs({ k: "prim", type: "string" }, void 0, void 0, conf);
+}
+function boolPrim(conf = "partial") {
+  return abs({ k: "prim", type: "boolean" }, void 0, void 0, conf);
+}
+function evalMathMethod(name, args) {
+  const a0 = args[0] ? litValue(args[0]) : void 0;
+  const a1 = args[1] ? litValue(args[1]) : void 0;
+  switch (name) {
+    case "abs":
+      if (typeof a0 === "number") return numLit(Math.abs(a0));
+      return numPrim();
+    case "floor":
+      if (typeof a0 === "number") return numLit(Math.floor(a0));
+      return numPrim();
+    case "ceil":
+      if (typeof a0 === "number") return numLit(Math.ceil(a0));
+      return numPrim();
+    case "round":
+      if (typeof a0 === "number") return numLit(Math.round(a0));
+      return numPrim();
+    case "sqrt":
+      if (typeof a0 === "number") return numLit(Math.sqrt(a0));
+      return numPrim();
+    case "min": {
+      const lits = args.map(litValue);
+      if (lits.length > 0 && lits.every((x) => typeof x === "number")) {
+        return numLit(Math.min(...lits));
       }
-      const r = transformValue(el);
-      if (r === REMOVE) {
-        changed = true;
-      } else {
-        if (r !== el) changed = true;
-        out.push(r);
+      return numPrim();
+    }
+    case "max": {
+      const lits = args.map(litValue);
+      if (lits.length > 0 && lits.every((x) => typeof x === "number")) {
+        return numLit(Math.max(...lits));
       }
+      return numPrim();
     }
-    return changed ? out : value;
-  }
-  if (typeof value !== "object" || value === null) return value;
-  if (typeof value.type !== "string") return value;
-  return transformNode(value);
-}
-function isTsDeclareLike(node) {
-  return node.declare === true;
-}
-function isTypeOnlyDeclaration(decl) {
-  switch (decl.type) {
-    case "TSInterfaceDeclaration":
-    case "TSTypeAliasDeclaration":
-    case "TSEnumDeclaration":
-    case "TSDeclareFunction":
-      return true;
-    case "VariableDeclaration":
-    case "ClassDeclaration":
-      return isTsDeclareLike(decl);
+    case "pow":
+      if (typeof a0 === "number" && typeof a1 === "number") return numLit(Math.pow(a0, a1));
+      return numPrim();
+    case "sign":
+      if (typeof a0 === "number") return numLit(Math.sign(a0));
+      return numPrim();
     default:
-      return false;
+      return void 0;
   }
 }
-function isTypeOnlyStatement(node) {
-  const anyNode = node;
-  switch (node.type) {
-    case "TSInterfaceDeclaration":
-    case "TSTypeAliasDeclaration":
-    case "TSEnumDeclaration":
-    case "TSDeclareFunction":
-      return true;
-    case "TSModuleDeclaration":
-      return isTsDeclareLike(node);
-    case "VariableDeclaration":
-    case "ClassDeclaration":
-      return isTsDeclareLike(node);
-    case "ImportDeclaration":
-      if (anyNode.importKind === "type") return true;
-      {
-        const specs = anyNode.specifiers;
-        if (specs && specs.length > 0 && specs.every((s) => s.importKind === "type" || s.importKind === "typeof")) {
-          return true;
-        }
+function evalObjectMethod(name, args) {
+  const a0 = args[0];
+  switch (name) {
+    case "keys": {
+      if (a0?.shape.k === "obj") {
+        const keys = Object.keys(a0.shape.slots).map(
+          (k) => strLit(k)
+        );
+        return abs({ k: "tuple", elements: keys }, void 0, void 0, "exact");
       }
-      return false;
-    case "ExportNamedDeclaration": {
-      if (anyNode.exportKind === "type") return true;
-      const decl = node.declaration;
-      if (decl && isTypeOnlyDeclaration(decl)) return true;
-      {
-        const specs = anyNode.specifiers;
-        if (!decl && specs && specs.length > 0 && specs.every((s) => s.exportKind === "type")) return true;
+      return abs({ k: "arr", element: strPrim("path") }, void 0, void 0, "partial");
+    }
+    case "values": {
+      if (a0?.shape.k === "obj") {
+        const slots = a0.shape.slots;
+        const vals = Object.values(slots).map((s) => s.value);
+        return abs({ k: "tuple", elements: vals }, void 0, void 0, "exact");
       }
-      return false;
+      return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
+    }
+    case "entries": {
+      if (a0?.shape.k === "obj") {
+        const slots = a0.shape.slots;
+        const entries = Object.entries(slots).map(
+          ([, s]) => abs({ k: "tuple", elements: [strPrim("exact"), s.value] }, void 0, void 0, "exact")
+        );
+        return abs({ k: "tuple", elements: entries }, void 0, void 0, "exact");
+      }
+      return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
+    }
+    case "assign": {
+      if (!args.length) return unknown;
+      let acc = args[0];
+      for (let i = 1; i < args.length; i++) {
+        acc = { ...acc };
+        if (acc.shape.k === "obj" && args[i].shape.k === "obj") {
+          const base = acc.shape.slots;
+          const over = args[i].shape.slots;
+          acc = abs({ k: "obj", slots: { ...base, ...over } }, void 0, void 0, confJoin(acc.conf, args[i].conf));
+        }
+      }
+      return acc;
     }
-    case "ExportAllDeclaration":
-      return anyNode.exportKind === "type";
-    case "ExportDefaultDeclaration":
-      return isTypeOnlyDeclaration(node.declaration);
-    // ---- 类成员 ----
-    case "TSIndexSignature":
-    case "TSDeclareMethod":
-      return true;
-    case "ClassProperty":
-    case "ClassPrivateProperty":
-      return isTsDeclareLike(node) || node.abstract === true;
     default:
-      return false;
+      return void 0;
   }
 }
-function deleteTypeSyntaxFields(node) {
-  const tp = node.typeParameters;
-  if (tp && typeof tp.type === "string" && tp.type.startsWith("TSTypeParameter")) {
-    delete node.typeParameters;
-  }
-  const ta = node.typeAnnotation;
-  if (ta && ta.type === "TSTypeAnnotation") delete node.typeAnnotation;
-  const rt = node.returnType;
-  if (rt && (rt.type === "TSTypeAnnotation" || rt.type === "TSTypePredicate")) delete node.returnType;
-  if (node.optional === true && (node.type === "Identifier" || node.type === "ObjectPattern" || node.type === "ArrayPattern" || node.type === "RestElement")) {
-    delete node.optional;
+function evalJsonMethod(name, args) {
+  if (name === "stringify") return strPrim("partial");
+  if (name === "parse") return unknown;
+  return void 0;
+}
+function evalNumberStatic(name, args) {
+  const a0 = args[0] ? litValue(args[0]) : void 0;
+  switch (name) {
+    case "isInteger":
+      if (typeof a0 === "number") return boolLit(Number.isInteger(a0));
+      return boolPrim();
+    case "isNaN":
+      if (typeof a0 === "number") return boolLit(Number.isNaN(a0));
+      return boolPrim();
+    case "isFinite":
+      if (typeof a0 === "number") return boolLit(Number.isFinite(a0));
+      return boolPrim();
+    case "parseInt":
+    case "parseFloat":
+      if (typeof a0 === "string" || typeof a0 === "number") {
+        const n = name === "parseInt" ? parseInt(String(a0), 10) : parseFloat(String(a0));
+        return numLit(n);
+      }
+      return numPrim();
+    case "MAX_SAFE_INTEGER":
+      return numLit(Number.MAX_SAFE_INTEGER);
+    default:
+      return void 0;
   }
-  if ("implements" in node) delete node.implements;
-  if ("superTypeParameters" in node) delete node.superTypeParameters;
 }
-function unwrapExpression(node) {
-  switch (node.type) {
-    case "TSAsExpression":
-    // 含 as const
-    case "TSSatisfiesExpression":
-    case "TSTypeAssertion":
-    case "TSNonNullExpression":
-    case "TSInstantiationExpression":
-      return node.expression;
+function evalGlobalFn(name, args) {
+  const a0 = args[0] ? litValue(args[0]) : void 0;
+  switch (name) {
+    case "parseInt":
+      if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseInt(String(a0), 10));
+      return numPrim();
+    case "parseFloat":
+      if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseFloat(String(a0)));
+      return numPrim();
+    case "isNaN":
+      if (typeof a0 === "number") return boolLit(Number.isNaN(a0));
+      return boolPrim();
+    case "Number":
+      if (typeof a0 === "number") return numLit(a0);
+      if (typeof a0 === "string") return numLit(Number(a0));
+      if (typeof a0 === "boolean") return numLit(a0 ? 1 : 0);
+      return numPrim();
+    case "String":
+      if (a0 !== void 0) return strLit(String(a0));
+      return strPrim();
+    case "Boolean":
+      if (a0 !== void 0) return boolLit(Boolean(a0));
+      return boolPrim();
     default:
-      return null;
+      return void 0;
   }
 }
-function transformNode(node) {
-  if (isTypeOnlyStatement(node)) return REMOVE;
-  deleteTypeSyntaxFields(node);
-  if (node.type === "ImportDeclaration") {
-    node.specifiers = node.specifiers.filter(
-      (s) => !(s.importKind === "type" || s.importKind === "typeof")
-    );
-  } else if (node.type === "ExportNamedDeclaration") {
-    if (node.specifiers) {
-      node.specifiers = node.specifiers.filter((s) => s.exportKind !== "type");
+function evalArrayStatic(name, args) {
+  const a0 = args[0];
+  switch (name) {
+    case "isArray": {
+      if (!a0) return boolLit(false);
+      const k = a0.shape.k;
+      return boolLit(k === "arr" || k === "tuple");
     }
-  }
-  for (const key of Object.keys(node)) {
-    if (SKIP_KEYS.has(key)) continue;
-    const child = node[key];
-    if (child === null || typeof child !== "object") continue;
-    const r = transformValue(child);
-    if (r === REMOVE) {
-      delete node[key];
-    } else {
-      node[key] = r;
+    case "of":
+      return abs({ k: "arr", element: a0 ?? unknown }, void 0, void 0, "path");
+    case "from": {
+      if (!a0) return unknown;
+      const k = a0.shape.k;
+      if (k === "arr") return a0;
+      if (k === "tuple") {
+        const els = a0.shape.elements;
+        if (els.length === 0) return abs({ k: "arr", element: unknown }, void 0, void 0, "path");
+        let el = els[0];
+        for (let i = 1; i < els.length; i++) el = joinAbs(el, els[i]);
+        return abs({ k: "arr", element: el }, void 0, void 0, "path");
+      }
+      if (k === "prim" && a0.shape.type === "string") {
+        return abs(
+          { k: "arr", element: abs({ k: "prim", type: "string" }, void 0, void 0, "path") },
+          void 0,
+          void 0,
+          "path"
+        );
+      }
+      return unknown;
     }
+    default:
+      return void 0;
   }
-  return unwrapExpression(node) ?? node;
 }
-function stripTypes(ast) {
-  transformValue(ast);
-  return ast;
+function evalDateCtor(args) {
+  return abs(
+    { k: "brand", name: "Date", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
+    void 0,
+    void 0,
+    "path"
+  );
 }
-
-// src/algebra/parse-source.ts
-var MAX_AST_CACHE = 16;
-var MAX_AST_SOURCE_CHARS = 1e6;
-var astCache = /* @__PURE__ */ new Map();
-function resetParseSourceCache() {
-  astCache.clear();
+function evalDateStatic(name, _args) {
+  if (name === "now") return numLit(Date.now());
+  return void 0;
 }
-function getParseSourceCacheSize() {
-  return astCache.size;
+function evalDateMethod(name, _recv, _args) {
+  switch (name) {
+    case "getTime":
+    case "valueOf":
+      return numPrim("path");
+    case "toISOString":
+    case "toString":
+      return strPrim("path");
+    default:
+      return void 0;
+  }
 }
-function parseUncached(source, opts) {
-  const ast = babelParse(source, {
-    sourceType: "module",
-    plugins: ["typescript", "jsx"],
-    attachComment: true,
-    errorRecovery: opts?.errorRecovery === true
-  });
-  return stripTypes(ast);
+function evalRegExpCtor(_args) {
+  return abs(
+    { k: "brand", name: "RegExp", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
+    void 0,
+    void 0,
+    "path"
+  );
 }
-function parseSource(source, opts) {
-  if (opts?.errorRecovery === true) {
-    return parseUncached(source, opts);
-  }
-  if (source.length > MAX_AST_SOURCE_CHARS) {
-    return parseUncached(source, opts);
-  }
-  const hit = astCache.get(source);
-  if (hit !== void 0) {
-    astCache.delete(source);
-    astCache.set(source, hit);
-    return hit;
-  }
-  const ast = parseUncached(source, opts);
-  if (astCache.size >= MAX_AST_CACHE) {
-    const oldest = astCache.keys().next().value;
-    if (oldest !== void 0) astCache.delete(oldest);
+function evalRegExpMethod(name, _recv, _args) {
+  switch (name) {
+    case "test":
+      return boolPrim();
+    case "exec":
+      return unknown;
+    default:
+      return void 0;
   }
-  astCache.set(source, ast);
-  return ast;
 }
-
-// src/algebra/leak.ts
-var defaultLeakBudget = {
-  maxDepth: 6,
-  maxNodes: 32
-};
-function termDepth(t) {
-  if (t.op !== "app") return 1;
-  return 1 + Math.max(0, ...t.args.map(termDepth));
+function evalPromiseCtor(_args) {
+  return abs(
+    { k: "eff", eff: "promise", inner: unknown },
+    void 0,
+    void 0,
+    "partial"
+  );
 }
-function termNodes(t) {
-  if (t.op !== "app") return 1;
-  return 1 + t.args.reduce((s, x) => s + termNodes(x), 0);
-}
-function exceedsBudget(t, budget = defaultLeakBudget) {
-  return termDepth(t) > budget.maxDepth || termNodes(t) > budget.maxNodes;
+function evalPromiseStatic(name, args) {
+  switch (name) {
+    case "resolve": {
+      const inner = args[0] ?? unknown;
+      if (inner.shape.k === "eff" && inner.shape.eff === "promise") return inner;
+      return abs({ k: "eff", eff: "promise", inner }, void 0, void 0, "path");
+    }
+    case "reject":
+      return abs({ k: "eff", eff: "promise", inner: unknown }, void 0, void 0, "partial");
+    case "all": {
+      const a0 = args[0];
+      if (a0?.shape.k === "arr" && a0.shape.element.shape.k === "eff") {
+        return abs(
+          { k: "eff", eff: "promise", inner: abs({ k: "arr", element: a0.shape.element.shape.inner }, void 0, void 0, "path") },
+          void 0,
+          void 0,
+          "path"
+        );
+      }
+      return abs({ k: "eff", eff: "promise", inner: abs({ k: "arr", element: unknown }, void 0, void 0, "partial") }, void 0, void 0, "partial");
+    }
+    default:
+      return void 0;
+  }
 }
-var leakCounter = 0;
-function resetLeakCounter() {
-  leakCounter = 0;
+function evalNamespaceCall(ns, method, args) {
+  switch (ns) {
+    case "Math":
+      return evalMathMethod(method, args);
+    case "Object":
+      return evalObjectMethod(method, args);
+    case "JSON":
+      return evalJsonMethod(method, args);
+    case "Number":
+      return evalNumberStatic(method, args);
+    case "Array":
+      return evalArrayStatic(method, args);
+    case "Date":
+      return evalDateStatic(method, args);
+    case "Promise":
+      return evalPromiseStatic(method, args);
+    default:
+      return void 0;
+  }
 }
-function maybeLeak(a, budget = defaultLeakBudget, label = "t") {
-  if (!a.term || a.term.op !== "app") return a;
-  if (!exceedsBudget(a.term, budget)) return a;
-  leakCounter += 1;
-  const id = `${label}$${leakCounter}`;
-  const fresh = v(id);
-  const linkage = eq(fresh, a.term);
-  return abs(a.shape, fresh, linkage, confJoin(a.conf, "path"));
+function evalBuiltinNew(className, args) {
+  switch (className) {
+    case "Date":
+      return evalDateCtor(args);
+    case "RegExp":
+      return evalRegExpCtor(args);
+    case "Promise":
+      return evalPromiseCtor(args);
+    case "Map":
+      return abs(
+        { k: "brand", name: "Map", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
+        void 0,
+        void 0,
+        "path"
+      );
+    case "Set":
+      return abs(
+        { k: "brand", name: "Set", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
+        void 0,
+        void 0,
+        "path"
+      );
+    default:
+      return void 0;
+  }
 }
-function leakIfNeeded(a, budget, label) {
-  return maybeLeak(a, budget, label);
+function evalBuiltinInstanceMethod(brandName, method, recv, args) {
+  if (brandName === "Date") return evalDateMethod(method, recv, args);
+  if (brandName === "RegExp") return evalRegExpMethod(method, recv, args);
+  if (brandName === "Map") {
+    switch (method) {
+      case "get":
+        return unknown;
+      case "has":
+        return boolPrim();
+      case "set":
+        return recv;
+      case "size":
+        return numPrim("path");
+      default:
+        return void 0;
+    }
+  }
+  if (brandName === "Set") {
+    switch (method) {
+      case "has":
+        return boolPrim();
+      case "add":
+        return recv;
+      case "size":
+        return numPrim("path");
+      default:
+        return void 0;
+    }
+  }
+  return void 0;
 }
 
-// src/algebra/hof.ts
-function createHofCollectCtx(paramNames, alphaIds) {
-  return {
-    paramNames,
-    alphaIds: new Set(alphaIds),
-    freshSeq: { n: 0 },
-    sites: [],
-    fnRels: /* @__PURE__ */ new Map(),
-    entryShapes: /* @__PURE__ */ new Map()
-  };
-}
-function alphaOf(absOrTerm, ctx) {
-  const t = absOrTerm && typeof absOrTerm === "object" && "shape" in absOrTerm ? absOrTerm.term : absOrTerm;
-  if (t?.op === "var" && ctx.alphaIds.has(t.id)) return t;
-  ctx.freshSeq.n += 1;
-  const id = `T${ctx.freshSeq.n}`;
-  ctx.alphaIds.add(id);
-  return v(id);
-}
-function betaOf(param) {
-  return v(`B:${param}`);
-}
-function promoteParamShape(env, param, promotedShape, opts) {
-  const prev = env.vars.get(param);
-  if (!prev) return false;
-  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") return false;
-  const next = {
-    shape: promotedShape,
-    term: prev.term,
-    pred: prev.pred,
-    conf: "path"
-  };
-  env.vars.set(param, next);
-  const hc = env.hofCollect;
-  if (hc && hc.paramNames.has(param)) {
-    if (promotedShape.k === "fn") {
-      if (!hc.fnRels.has(param) && !hc.entryShapes.has(param)) {
-        hc.fnRels.set(param, { abs: { ...next }, source: "promote" });
+// src/algebra/exec/calls.ts
+var calls_exports = {};
+__export(calls_exports, {
+  $callNamed: () => $callNamed,
+  getAbsOrigin: () => getAbsOrigin,
+  getBCallCollector: () => getBCallCollector,
+  noteMemberDispatchMiss: () => noteMemberDispatchMiss,
+  notePrimMemberMissing: () => notePrimMemberMissing,
+  noteUnknownMemberMissing: () => noteUnknownMemberMissing,
+  recordMemberDiag: () => recordMemberDiag,
+  setBCallCollector: () => setBCallCollector,
+  setMemberDiagCollector: () => setMemberDiagCollector,
+  tagAbsOrigin: () => tagAbsOrigin
+});
+
+// src/algebra/parse-source.ts
+import { parse as babelParse } from "@babel/parser";
+
+// src/strip-types.ts
+var REMOVE = Symbol("nudo.strip.remove");
+var SKIP_KEYS = /* @__PURE__ */ new Set([
+  "loc",
+  "start",
+  "end",
+  "range",
+  "leadingComments",
+  "trailingComments",
+  "innerComments",
+  "comments",
+  "tokens",
+  "extra"
+]);
+function transformValue(value) {
+  if (Array.isArray(value)) {
+    let changed = false;
+    const out = [];
+    for (const el of value) {
+      if (el === null || el === void 0) {
+        out.push(el);
+        continue;
       }
-    } else {
-      if (!hc.fnRels.has(param) && !hc.entryShapes.has(param)) {
-        hc.entryShapes.set(param, { abs: { ...next }, source: "promote" });
+      const r = transformValue(el);
+      if (r === REMOVE) {
+        changed = true;
+      } else {
+        if (r !== el) changed = true;
+        out.push(r);
       }
     }
-    if (opts?.recordSite !== false && promotedShape.k === "fn") {
-      const result = promotedShape.returnType ?? next;
-      hc.sites.push({
-        param,
-        argTerms: [],
-        result,
-        loc: opts?.loc
-      });
-    }
+    return changed ? out : value;
   }
-  return true;
-}
-var HOF_ARR_METHODS = /* @__PURE__ */ new Set(["map", "filter", "reduce", "flatMap"]);
-function promoteParamAsArr(env, name, loc) {
-  const hc = env.hofCollect;
-  if (!hc || !hc.paramNames.has(name)) return void 0;
-  const prev = env.vars.get(name);
-  if (!prev) return void 0;
-  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") return void 0;
-  const element = prev.term ? abs(prev.shape, prev.term, prev.pred, "path") : abs({ k: "any" }, void 0, void 0, "path");
-  const arrShape = { k: "arr", element };
-  promoteParamShape(env, name, arrShape, { loc });
-  return env.vars.get(name);
+  if (typeof value !== "object" || value === null) return value;
+  if (typeof value.type !== "string") return value;
+  return transformNode(value);
 }
-function tryPromoteReceiverAsArr(env, receiverName, method, loc) {
-  if (!HOF_ARR_METHODS.has(method)) return void 0;
-  return promoteParamAsArr(env, receiverName, loc);
+function isTsDeclareLike(node) {
+  return node.declare === true;
 }
-function tryPromoteForOfIteratee(env, iterateeName, loc) {
-  return promoteParamAsArr(env, iterateeName, loc);
+function isTypeOnlyDeclaration(decl) {
+  switch (decl.type) {
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "TSEnumDeclaration":
+    case "TSDeclareFunction":
+      return true;
+    case "VariableDeclaration":
+    case "ClassDeclaration":
+      return isTsDeclareLike(decl);
+    default:
+      return false;
+  }
 }
-function tryPromoteDirectCall(env, calleeName, args, loc) {
-  const hc = env.hofCollect;
-  if (!hc || !hc.paramNames.has(calleeName)) return void 0;
-  const prev = env.vars.get(calleeName);
-  if (!prev) return void 0;
-  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") {
-    if (prev.shape.k === "fn") {
-      hc.sites.push({
-        param: calleeName,
-        argTerms: args.map((a) => a.term ?? { op: "var", id: "_" }),
-        result: prev.shape.returnType ?? prev,
-        loc
-      });
-    }
-    return void 0;
-  }
-  const paramTypes = args.map(
-    (a) => abs({ k: "any" }, alphaOf(a, hc), void 0, "path")
-  );
-  const ret = abs({ k: "any" }, betaOf(calleeName), void 0, "path");
-  const fnShape = {
-    k: "fn",
-    params: args.map((_, i) => `x${i}`),
-    paramTypes,
-    returnType: ret
-  };
-  promoteParamShape(env, calleeName, fnShape, { loc, recordSite: false });
-  hc.sites.push({
-    param: calleeName,
-    argTerms: args.map((a) => a.term ?? { op: "var", id: "_" }),
-    result: ret,
-    loc
-  });
-  return env.vars.get(calleeName);
-}
-function tryPromoteHofCallback(env, cbName, method, argAbses, loc) {
-  const hc = env.hofCollect;
-  if (!hc || !hc.paramNames.has(cbName)) return void 0;
-  const prev = env.vars.get(cbName);
-  if (!prev) return void 0;
-  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") return void 0;
-  let paramTypes;
-  let returnType;
-  if (method === "filter") {
-    paramTypes = argAbses.map(
-      (a) => abs({ k: "any" }, alphaOf(a, hc), void 0, "path")
-    );
-    returnType = abs({ k: "prim", type: "boolean" }, void 0, void 0, "path");
-  } else if (method === "reduce") {
-    paramTypes = argAbses.map(
-      (a) => abs({ k: "any" }, alphaOf(a, hc), void 0, "path")
-    );
-    returnType = abs({ k: "any" }, betaOf(cbName), void 0, "path");
-  } else {
-    paramTypes = argAbses.map(
-      (a) => abs({ k: "any" }, alphaOf(a, hc), void 0, "path")
-    );
-    returnType = abs({ k: "any" }, betaOf(cbName), void 0, "path");
-  }
-  const fnShape = {
-    k: "fn",
-    params: argAbses.map((_, i) => `x${i}`),
-    paramTypes,
-    returnType
-  };
-  promoteParamShape(env, cbName, fnShape, { loc, recordSite: false });
-  hc.sites.push({
-    param: cbName,
-    argTerms: argAbses.map((a) => a.term ?? { op: "var", id: "_" }),
-    result: returnType,
-    loc
-  });
-  return env.vars.get(cbName);
-}
-function snapshotAbs(a) {
-  const shape = a.shape;
-  const copyShape = (s) => {
-    switch (s.k) {
-      case "arr":
-        return { ...s, element: snapshotAbs(s.element) };
-      case "tuple": {
-        const next = {
-          k: "tuple",
-          elements: s.elements.map(snapshotAbs)
-        };
-        if (s.rest) next.rest = snapshotAbs(s.rest);
-        return next;
-      }
-      case "fn": {
-        const next = { k: "fn", params: [...s.params] };
-        if (s.name !== void 0) next.name = s.name;
-        if (s.paramTypes) next.paramTypes = s.paramTypes.map(snapshotAbs);
-        if (s.returnType) next.returnType = snapshotAbs(s.returnType);
-        return next;
-      }
-      case "sum":
-        return { ...s, members: s.members.map(snapshotAbs) };
-      case "obj": {
-        const slots = {};
-        for (const [k, slot] of Object.entries(s.slots)) {
-          const nextSlot = { value: snapshotAbs(slot.value) };
-          if (slot.optional) nextSlot.optional = true;
-          if (slot.readonly) nextSlot.readonly = true;
-          slots[k] = nextSlot;
-        }
-        const next = { k: "obj", slots };
-        if (s.index) {
-          next.index = {
-            key: snapshotAbs(s.index.key),
-            value: snapshotAbs(s.index.value)
-          };
-        }
-        if (s.open) next.open = true;
-        return next;
-      }
-      case "brand":
-        return { ...s, shape: snapshotAbs(s.shape) };
-      case "eff":
-        return { ...s, inner: snapshotAbs(s.inner) };
-      default:
-        return s;
-    }
-  };
-  return {
-    shape: copyShape(shape),
-    term: a.term,
-    pred: a.pred,
-    conf: a.conf
-  };
-}
-function isRelFn(a) {
-  if (!a || typeof a !== "object") return false;
-  if (getFnImpl(a)) return false;
-  const s = a.shape;
-  if (!s || s.k !== "fn") return false;
-  if (s.returnType === void 0) return false;
-  if (s.paramTypes === void 0) return s.params.length === 0;
-  return s.paramTypes.length === s.params.length;
-}
-function litOfTerm(t) {
-  return t.op === "lit" ? t.value : void 0;
-}
-function foldCompare(op, a, b) {
-  if (a === void 0 || b === void 0) return void 0;
-  if (typeof a !== typeof b) {
-    if (op === "eq") return pFalse;
-    if (op === "ne") return pTrue;
-    return void 0;
-  }
-  switch (op) {
-    case "eq":
-      return a === b ? pTrue : pFalse;
-    case "ne":
-      return a !== b ? pTrue : pFalse;
-    case "lt":
-      return a < b ? pTrue : pFalse;
-    case "le":
-      return a <= b ? pTrue : pFalse;
-    case "gt":
-      return a > b ? pTrue : pFalse;
-    case "ge":
-      return a >= b ? pTrue : pFalse;
-    default:
-      return void 0;
-  }
-}
-function predUsesMappedVars(p, map) {
-  const walkTerm = (t) => {
-    if (t.op === "var") return map.has(t.id);
-    if (t.op === "app") return t.args.some(walkTerm);
-    return false;
-  };
-  const walk = (q) => {
-    switch (q.op) {
-      case "true":
-      case "false":
-        return false;
-      case "eq":
-      case "ne":
-      case "lt":
-      case "le":
-      case "gt":
-      case "ge":
-        return walkTerm(q.a) || walkTerm(q.b);
-      case "and":
-      case "or":
-        return q.args.some(walk);
-      case "not":
-        return walk(q.arg);
-      case "typeof":
-        return walkTerm(q.t);
-    }
-  };
-  return walk(p);
-}
-function mapHasShapeOnlyVar(p, map) {
-  const walkTerm = (t) => {
-    if (t.op === "var") {
-      const arg = map.get(t.id);
-      return !!arg && arg.term === void 0;
-    }
-    if (t.op === "app") return t.args.some(walkTerm);
-    return false;
-  };
-  const walk = (q) => {
-    switch (q.op) {
-      case "true":
-      case "false":
-        return false;
-      case "eq":
-      case "ne":
-      case "lt":
-      case "le":
-      case "gt":
-      case "ge":
-        return walkTerm(q.a) || walkTerm(q.b);
-      case "and":
-      case "or":
-        return q.args.some(walk);
-      case "not":
-        return walk(q.arg);
-      case "typeof":
-        return walkTerm(q.t);
-    }
-  };
-  return walk(p);
-}
-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) => {
-    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 t;
-  };
-  const replaced = substPred(p, substTerm);
-  const fold = (q) => {
-    switch (q.op) {
-      case "true":
-      case "false":
-        return q;
-      case "eq":
-      case "ne":
-      case "lt":
-      case "le":
-      case "gt":
-      case "ge": {
-        const a = litOfTerm(q.a);
-        const b = litOfTerm(q.b);
-        const folded = foldCompare(q.op, a, b);
-        return folded ?? q;
-      }
-      case "and": {
-        const args = q.args.map(fold);
-        if (args.some((x) => x.op === "false")) return pFalse;
-        const rest = args.filter((x) => x.op !== "true");
-        if (rest.length === 0) return pTrue;
-        if (rest.length === 1) return rest[0];
-        return and(...rest);
-      }
-      case "or": {
-        const args = q.args.map(fold);
-        if (args.some((x) => x.op === "true")) return pTrue;
-        const rest = args.filter((x) => x.op !== "false");
-        if (rest.length === 0) return pFalse;
-        if (rest.length === 1) return rest[0];
-        return { op: "or", args: rest };
+function isTypeOnlyStatement(node) {
+  const anyNode = node;
+  switch (node.type) {
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "TSEnumDeclaration":
+    case "TSDeclareFunction":
+      return true;
+    case "TSModuleDeclaration":
+      return isTsDeclareLike(node);
+    case "VariableDeclaration":
+    case "ClassDeclaration":
+      return isTsDeclareLike(node);
+    case "ImportDeclaration":
+      if (anyNode.importKind === "type") return true;
+      {
+        const specs = anyNode.specifiers;
+        if (specs && specs.length > 0 && specs.every((s) => s.importKind === "type" || s.importKind === "typeof")) {
+          return true;
+        }
       }
-      case "not": {
-        const inner = fold(q.arg);
-        if (inner.op === "true") return pFalse;
-        if (inner.op === "false") return pTrue;
-        return { op: "not", arg: inner };
+      return false;
+    case "ExportNamedDeclaration": {
+      if (anyNode.exportKind === "type") return true;
+      const decl = node.declaration;
+      if (decl && isTypeOnlyDeclaration(decl)) return true;
+      {
+        const specs = anyNode.specifiers;
+        if (!decl && specs && specs.length > 0 && specs.every((s) => s.exportKind === "type")) return true;
       }
-      case "typeof":
-        return q;
+      return false;
     }
-  };
-  return { pred: fold(replaced), dropped: false };
+    case "ExportAllDeclaration":
+      return anyNode.exportKind === "type";
+    case "ExportDefaultDeclaration":
+      return isTypeOnlyDeclaration(node.declaration);
+    // ---- 类成员 ----
+    case "TSIndexSignature":
+    case "TSDeclareMethod":
+      return true;
+    case "ClassProperty":
+    case "ClassPrivateProperty":
+      return isTsDeclareLike(node) || node.abstract === true;
+    default:
+      return false;
+  }
 }
-function substTermAbs(t, map) {
-  if (t.op === "var") {
-    const arg = map.get(t.id);
-    return arg?.term ?? t;
+function deleteTypeSyntaxFields(node) {
+  const tp = node.typeParameters;
+  if (tp && typeof tp.type === "string" && tp.type.startsWith("TSTypeParameter")) {
+    delete node.typeParameters;
   }
-  if (t.op === "app") {
-    return simplifyTerm({
-      op: "app",
-      fn: t.fn,
-      args: t.args.map((x) => substTermAbs(x, map))
-    });
+  const ta = node.typeAnnotation;
+  if (ta && ta.type === "TSTypeAnnotation") delete node.typeAnnotation;
+  const rt = node.returnType;
+  if (rt && (rt.type === "TSTypeAnnotation" || rt.type === "TSTypePredicate")) delete node.returnType;
+  if (node.optional === true && (node.type === "Identifier" || node.type === "ObjectPattern" || node.type === "ArrayPattern" || node.type === "RestElement")) {
+    delete node.optional;
   }
-  return t;
+  if ("implements" in node) delete node.implements;
+  if ("superTypeParameters" in node) delete node.superTypeParameters;
 }
-function substShape(s, map, cache, visiting) {
-  switch (s.k) {
-    case "never":
-    case "any":
-    case "unknown":
-    case "prim":
-      return s;
-    case "brand":
-      return { ...s, shape: substAbsInner(s.shape, map, cache, visiting) };
-    case "eff":
-      return { ...s, inner: substAbsInner(s.inner, map, cache, visiting) };
-    case "arr":
-      return { ...s, element: substAbsInner(s.element, map, cache, visiting) };
-    case "tuple": {
-      const elements = s.elements.map(
-        (e) => substAbsInner(e, map, cache, visiting)
-      );
-      const next = { k: "tuple", elements };
-      if (s.rest) next.rest = substAbsInner(s.rest, map, cache, visiting);
-      return next;
-    }
-    case "fn": {
-      const next = { k: "fn", params: s.params };
-      if (s.name !== void 0) next.name = s.name;
-      if (s.paramTypes) {
-        next.paramTypes = s.paramTypes.map(
-          (p) => substAbsInner(p, map, cache, visiting)
-        );
-      }
-      if (s.returnType !== void 0) {
-        next.returnType = substAbsInner(s.returnType, map, cache, visiting);
-      }
-      return next;
-    }
-    case "sum":
-      return {
-        ...s,
-        members: s.members.map((m) => substAbsInner(m, map, cache, visiting))
-      };
-    case "obj": {
-      const slots = {};
-      for (const [k, slot] of Object.entries(s.slots)) {
-        const nextSlot = { value: substAbsInner(slot.value, map, cache, visiting) };
-        if (slot.optional) nextSlot.optional = true;
-        if (slot.readonly) nextSlot.readonly = true;
-        slots[k] = nextSlot;
-      }
-      const next = { k: "obj", slots };
-      if (s.index) {
-        next.index = {
-          key: substAbsInner(s.index.key, map, cache, visiting),
-          value: substAbsInner(s.index.value, map, cache, visiting)
-        };
-      }
-      if (s.open) next.open = true;
-      return next;
-    }
+function unwrapExpression(node) {
+  switch (node.type) {
+    case "TSAsExpression":
+    // 含 as const
+    case "TSSatisfiesExpression":
+    case "TSTypeAssertion":
+    case "TSNonNullExpression":
+    case "TSInstantiationExpression":
+      return node.expression;
+    default:
+      return null;
   }
 }
-function substAbsInner(a, map, cache, visiting) {
-  if (a.term?.op === "var" && map.has(a.term.id)) {
-    const repl = map.get(a.term.id);
-    return {
-      shape: repl.shape,
-      term: repl.term,
-      pred: repl.pred,
-      conf: confJoin(a.conf, repl.conf)
-    };
+function transformNode(node) {
+  if (isTypeOnlyStatement(node)) return REMOVE;
+  deleteTypeSyntaxFields(node);
+  if (node.type === "ImportDeclaration") {
+    node.specifiers = node.specifiers.filter(
+      (s) => !(s.importKind === "type" || s.importKind === "typeof")
+    );
+  } else if (node.type === "ExportNamedDeclaration") {
+    if (node.specifiers) {
+      node.specifiers = node.specifiers.filter((s) => s.exportKind !== "type");
+    }
   }
-  const hit = cache.get(a);
-  if (hit !== void 0) return hit;
-  if (visiting.has(a)) return a;
-  visiting.add(a);
-  const shape = substShape(a.shape, map, cache, visiting);
-  const term = a.term ? substTermAbs(a.term, map) : void 0;
-  let pred = a.pred;
-  let conf = a.conf;
-  if (a.pred) {
-    const r = substPredAbs(a.pred, map);
-    pred = r.pred;
-    if (r.dropped) conf = confJoin(conf, "partial");
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS.has(key)) continue;
+    const child = node[key];
+    if (child === null || typeof child !== "object") continue;
+    const r = transformValue(child);
+    if (r === REMOVE) {
+      delete node[key];
+    } else {
+      node[key] = r;
+    }
   }
-  visiting.delete(a);
-  const result = abs(shape, term, pred, conf);
-  cache.set(a, result);
-  return result;
+  return unwrapExpression(node) ?? node;
 }
-function substAbs(a, map) {
-  if (map.size === 0) return a;
-  return substAbsInner(a, map, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+function stripTypes(ast) {
+  transformValue(ast);
+  return ast;
 }
-function instantiateReturn(fn, args) {
-  const shape = fn.shape;
-  if (!shape || shape.k !== "fn") return unknown;
-  const src = getFnImpl(fn)?.relation ?? {
-    paramTypes: shape.paramTypes ?? [],
-    returnType: shape.returnType ?? unknown
-  };
-  const map = /* @__PURE__ */ new Map();
-  src.paramTypes.forEach((p, i) => {
-    if (p.term?.op !== "var") return;
-    const id = p.term.id;
-    if (map.has(id)) return;
-    map.set(id, args[i] ?? unknown);
-  });
-  return substAbs(src.returnType, map);
+
+// src/algebra/parse-source.ts
+var MAX_AST_CACHE = 16;
+var MAX_AST_SOURCE_CHARS = 1e6;
+var astCache = /* @__PURE__ */ new Map();
+function resetParseSourceCache() {
+  astCache.clear();
 }
-var applyCallbackHost;
-function setApplyCallbackHost(fn) {
-  applyCallbackHost = fn;
+function getParseSourceCacheSize() {
+  return astCache.size;
 }
-function applyCallbackAbs(cb, args, env, phi2, budget) {
-  if (!applyCallbackHost) {
-    if (cb && typeof cb === "object" && "shape" in cb) {
-      const a = cb;
-      const impl = getFnImpl(a);
-      if (impl?.relation) return instantiateReturn(a, args);
-      if (isRelFn(a)) return instantiateReturn(a, args);
-    }
-    return unknown;
+function parseUncached(source, opts) {
+  const ast = babelParse(source, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"],
+    attachComment: true,
+    errorRecovery: opts?.errorRecovery === true
+  });
+  return opts?.keepTs === true ? ast : stripTypes(ast);
+}
+function parseSource(source, opts) {
+  if (opts?.keepTs === true || opts?.errorRecovery === true) {
+    return parseUncached(source, opts);
   }
-  return applyCallbackHost(cb, args, env, phi2, budget);
+  if (source.length > MAX_AST_SOURCE_CHARS) {
+    return parseUncached(source, opts);
+  }
+  const hit = astCache.get(source);
+  if (hit !== void 0) {
+    astCache.delete(source);
+    astCache.set(source, hit);
+    return hit;
+  }
+  const ast = parseUncached(source, opts);
+  if (astCache.size >= MAX_AST_CACHE) {
+    const oldest = astCache.keys().next().value;
+    if (oldest !== void 0) astCache.delete(oldest);
+  }
+  astCache.set(source, ast);
+  return ast;
+}
+
+// src/algebra/leak.ts
+var defaultLeakBudget = {
+  maxDepth: 6,
+  maxNodes: 32
+};
+function termDepth(t) {
+  if (t.op !== "app") return 1;
+  return 1 + Math.max(0, ...t.args.map(termDepth));
+}
+function termNodes(t) {
+  if (t.op !== "app") return 1;
+  return 1 + t.args.reduce((s, x) => s + termNodes(x), 0);
 }
-function undefAbs() {
-  return abs(
-    { k: "unknown" },
-    { op: "lit", value: void 0 },
-    pTrue,
-    "exact"
-  );
+function exceedsBudget(t, budget = defaultLeakBudget) {
+  return termDepth(t) > budget.maxDepth || termNodes(t) > budget.maxNodes;
 }
-function mapElementFallback(cbAbs, elem, out) {
-  if (out.shape.k !== "unknown" || elem.term?.op !== "var") return out;
-  const slot = cbAbs?.shape.k === "fn" ? cbAbs.shape.returnType : void 0;
-  return slot ?? out;
+var leakCounter = 0;
+function resetLeakCounter() {
+  leakCounter = 0;
 }
-function projectFlatMapResult(arrConf, mapped) {
-  const flatEls = [];
-  let anyUnknown = false;
-  for (const m of mapped) {
-    if (m.shape.k === "arr") flatEls.push(m.shape.element);
-    else if (m.shape.k === "tuple") flatEls.push(...m.shape.elements);
-    else anyUnknown = true;
-  }
-  if (anyUnknown || flatEls.length === 0) return unknown;
-  const first = flatEls[0];
-  const sameIdentity = flatEls.every((e) => {
-    if (e.shape.k !== first.shape.k) return false;
-    if (!e.term && !first.term) return true;
-    if (!e.term || !first.term) return false;
-    return termToString(e.term) === termToString(first.term);
-  });
-  const el = sameIdentity ? first : flatEls.reduce((a, b) => joinAbs(a, b));
-  return abs(
-    { k: "arr", element: el },
-    void 0,
-    void 0,
-    confJoin(arrConf, "path")
-  );
+function maybeLeak(a, budget = defaultLeakBudget, label = "t") {
+  if (!a.term || a.term.op !== "app") return a;
+  if (!exceedsBudget(a.term, budget)) return a;
+  leakCounter += 1;
+  const id = `${label}$${leakCounter}`;
+  const fresh = v(id);
+  const linkage = eq(fresh, a.term);
+  return abs(a.shape, fresh, linkage, confJoin(a.conf, "path"));
 }
-function asAbs(v2) {
-  if (v2 && typeof v2 === "object" && "shape" in v2) return v2;
-  return void 0;
+function leakIfNeeded(a, budget, label) {
+  return maybeLeak(a, budget, label);
 }
 
-// src/algebra/builtins.ts
-function numPrim(conf = "path") {
-  return abs({ k: "prim", type: "number" }, void 0, void 0, conf);
+// src/algebra/hof.ts
+function createHofCollectCtx(paramNames, alphaIds) {
+  return {
+    paramNames,
+    alphaIds: new Set(alphaIds),
+    freshSeq: { n: 0 },
+    sites: [],
+    fnRels: /* @__PURE__ */ new Map(),
+    entryShapes: /* @__PURE__ */ new Map()
+  };
 }
-function strPrim(conf = "path") {
-  return abs({ k: "prim", type: "string" }, void 0, void 0, conf);
+function alphaOf(absOrTerm, ctx) {
+  const t = absOrTerm && typeof absOrTerm === "object" && "shape" in absOrTerm ? absOrTerm.term : absOrTerm;
+  if (t?.op === "var" && ctx.alphaIds.has(t.id)) return t;
+  ctx.freshSeq.n += 1;
+  const id = `T${ctx.freshSeq.n}`;
+  ctx.alphaIds.add(id);
+  return v(id);
 }
-function boolPrim(conf = "partial") {
-  return abs({ k: "prim", type: "boolean" }, void 0, void 0, conf);
+function betaOf(param) {
+  return v(`B:${param}`);
 }
-function evalMathMethod(name, args) {
-  const a0 = args[0] ? litValue(args[0]) : void 0;
-  const a1 = args[1] ? litValue(args[1]) : void 0;
-  switch (name) {
-    case "abs":
-      if (typeof a0 === "number") return numLit(Math.abs(a0));
-      return numPrim();
-    case "floor":
-      if (typeof a0 === "number") return numLit(Math.floor(a0));
-      return numPrim();
-    case "ceil":
-      if (typeof a0 === "number") return numLit(Math.ceil(a0));
-      return numPrim();
-    case "round":
-      if (typeof a0 === "number") return numLit(Math.round(a0));
-      return numPrim();
-    case "sqrt":
-      if (typeof a0 === "number") return numLit(Math.sqrt(a0));
-      return numPrim();
-    case "min": {
-      const lits = args.map(litValue);
-      if (lits.length > 0 && lits.every((x) => typeof x === "number")) {
-        return numLit(Math.min(...lits));
+function promoteParamShape(env, param, promotedShape, opts) {
+  const prev = env.vars.get(param);
+  if (!prev) return false;
+  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") return false;
+  const next = {
+    shape: promotedShape,
+    term: prev.term,
+    pred: prev.pred,
+    conf: "path"
+  };
+  env.vars.set(param, next);
+  const hc = env.hofCollect;
+  if (hc && hc.paramNames.has(param)) {
+    if (promotedShape.k === "fn") {
+      if (!hc.fnRels.has(param) && !hc.entryShapes.has(param)) {
+        hc.fnRels.set(param, { abs: { ...next }, source: "promote" });
       }
-      return numPrim();
-    }
-    case "max": {
-      const lits = args.map(litValue);
-      if (lits.length > 0 && lits.every((x) => typeof x === "number")) {
-        return numLit(Math.max(...lits));
+    } else {
+      if (!hc.fnRels.has(param) && !hc.entryShapes.has(param)) {
+        hc.entryShapes.set(param, { abs: { ...next }, source: "promote" });
       }
-      return numPrim();
     }
-    case "pow":
-      if (typeof a0 === "number" && typeof a1 === "number") return numLit(Math.pow(a0, a1));
-      return numPrim();
-    case "sign":
-      if (typeof a0 === "number") return numLit(Math.sign(a0));
-      return numPrim();
-    default:
-      return void 0;
+    if (opts?.recordSite !== false && promotedShape.k === "fn") {
+      const result = promotedShape.returnType ?? next;
+      hc.sites.push({
+        param,
+        argTerms: [],
+        result,
+        loc: opts?.loc
+      });
+    }
   }
+  return true;
 }
-function evalObjectMethod(name, args) {
-  const a0 = args[0];
-  switch (name) {
-    case "keys": {
-      if (a0?.shape.k === "obj") {
-        const keys = Object.keys(a0.shape.slots).map(
-          (k) => strLit(k)
-        );
-        return abs({ k: "tuple", elements: keys }, void 0, void 0, "exact");
-      }
-      return abs({ k: "arr", element: strPrim("path") }, void 0, void 0, "partial");
+var HOF_ARR_METHODS = /* @__PURE__ */ new Set(["map", "filter", "reduce", "flatMap"]);
+function promoteParamAsArr(env, name, loc) {
+  const hc = env.hofCollect;
+  if (!hc || !hc.paramNames.has(name)) return void 0;
+  const prev = env.vars.get(name);
+  if (!prev) return void 0;
+  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") return void 0;
+  const element = prev.term ? abs(prev.shape, prev.term, prev.pred, "path") : abs({ k: "any" }, void 0, void 0, "path");
+  const arrShape = { k: "arr", element };
+  promoteParamShape(env, name, arrShape, { loc });
+  return env.vars.get(name);
+}
+function tryPromoteReceiverAsArr(env, receiverName, method, loc) {
+  if (!HOF_ARR_METHODS.has(method)) return void 0;
+  return promoteParamAsArr(env, receiverName, loc);
+}
+function tryPromoteForOfIteratee(env, iterateeName, loc) {
+  return promoteParamAsArr(env, iterateeName, loc);
+}
+function tryPromoteDirectCall(env, calleeName, args, loc) {
+  const hc = env.hofCollect;
+  if (!hc || !hc.paramNames.has(calleeName)) return void 0;
+  const prev = env.vars.get(calleeName);
+  if (!prev) return void 0;
+  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") {
+    if (prev.shape.k === "fn") {
+      hc.sites.push({
+        param: calleeName,
+        argTerms: args.map((a) => a.term ?? { op: "var", id: "_" }),
+        result: prev.shape.returnType ?? prev,
+        loc
+      });
     }
-    case "values": {
-      if (a0?.shape.k === "obj") {
-        const slots = a0.shape.slots;
-        const vals = Object.values(slots).map((s) => s.value);
-        return abs({ k: "tuple", elements: vals }, void 0, void 0, "exact");
+    return void 0;
+  }
+  const paramTypes = args.map(
+    (a) => abs({ k: "any" }, alphaOf(a, hc), void 0, "path")
+  );
+  const ret = abs({ k: "any" }, betaOf(calleeName), void 0, "path");
+  const fnShape = {
+    k: "fn",
+    params: args.map((_, i) => `x${i}`),
+    paramTypes,
+    returnType: ret
+  };
+  promoteParamShape(env, calleeName, fnShape, { loc, recordSite: false });
+  hc.sites.push({
+    param: calleeName,
+    argTerms: args.map((a) => a.term ?? { op: "var", id: "_" }),
+    result: ret,
+    loc
+  });
+  return env.vars.get(calleeName);
+}
+function tryPromoteHofCallback(env, cbName, method, argAbses, loc) {
+  const hc = env.hofCollect;
+  if (!hc || !hc.paramNames.has(cbName)) return void 0;
+  const prev = env.vars.get(cbName);
+  if (!prev) return void 0;
+  if (prev.shape.k !== "any" && prev.shape.k !== "unknown") return void 0;
+  let paramTypes;
+  let returnType;
+  if (method === "filter") {
+    paramTypes = argAbses.map(
+      (a) => abs({ k: "any" }, alphaOf(a, hc), void 0, "path")
+    );
+    returnType = abs({ k: "prim", type: "boolean" }, void 0, void 0, "path");
+  } else if (method === "reduce") {
+    paramTypes = argAbses.map(
+      (a) => abs({ k: "any" }, alphaOf(a, hc), void 0, "path")
+    );
+    returnType = abs({ k: "any" }, betaOf(cbName), void 0, "path");
+  } else {
+    paramTypes = argAbses.map(
+      (a) => abs({ k: "any" }, alphaOf(a, hc), void 0, "path")
+    );
+    returnType = abs({ k: "any" }, betaOf(cbName), void 0, "path");
+  }
+  const fnShape = {
+    k: "fn",
+    params: argAbses.map((_, i) => `x${i}`),
+    paramTypes,
+    returnType
+  };
+  promoteParamShape(env, cbName, fnShape, { loc, recordSite: false });
+  hc.sites.push({
+    param: cbName,
+    argTerms: argAbses.map((a) => a.term ?? { op: "var", id: "_" }),
+    result: returnType,
+    loc
+  });
+  return env.vars.get(cbName);
+}
+function snapshotAbs(a) {
+  const shape = a.shape;
+  const copyShape = (s) => {
+    switch (s.k) {
+      case "arr":
+        return { ...s, element: snapshotAbs(s.element) };
+      case "tuple": {
+        const next = {
+          k: "tuple",
+          elements: s.elements.map(snapshotAbs)
+        };
+        if (s.rest) next.rest = snapshotAbs(s.rest);
+        return next;
       }
-      return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
-    }
-    case "entries": {
-      if (a0?.shape.k === "obj") {
-        const slots = a0.shape.slots;
-        const entries = Object.entries(slots).map(
-          ([, s]) => abs({ k: "tuple", elements: [strPrim("exact"), s.value] }, void 0, void 0, "exact")
-        );
-        return abs({ k: "tuple", elements: entries }, void 0, void 0, "exact");
+      case "fn": {
+        const next = { k: "fn", params: [...s.params] };
+        if (s.name !== void 0) next.name = s.name;
+        if (s.paramTypes) next.paramTypes = s.paramTypes.map(snapshotAbs);
+        if (s.returnType) next.returnType = snapshotAbs(s.returnType);
+        return next;
       }
-      return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
-    }
-    case "assign": {
-      if (!args.length) return unknown;
-      let acc = args[0];
-      for (let i = 1; i < args.length; i++) {
-        acc = { ...acc };
-        if (acc.shape.k === "obj" && args[i].shape.k === "obj") {
-          const base = acc.shape.slots;
-          const over = args[i].shape.slots;
-          acc = abs({ k: "obj", slots: { ...base, ...over } }, void 0, void 0, confJoin(acc.conf, args[i].conf));
+      case "sum":
+        return { ...s, members: s.members.map(snapshotAbs) };
+      case "obj": {
+        const slots = {};
+        for (const [k, slot] of Object.entries(s.slots)) {
+          const nextSlot = { value: snapshotAbs(slot.value) };
+          if (slot.optional) nextSlot.optional = true;
+          if (slot.readonly) nextSlot.readonly = true;
+          slots[k] = nextSlot;
+        }
+        const next = { k: "obj", slots };
+        if (s.index) {
+          next.index = {
+            key: snapshotAbs(s.index.key),
+            value: snapshotAbs(s.index.value)
+          };
         }
+        if (s.open) next.open = true;
+        return next;
       }
-      return acc;
+      case "brand":
+        return { ...s, shape: snapshotAbs(s.shape) };
+      case "eff":
+        return { ...s, inner: snapshotAbs(s.inner) };
+      default:
+        return s;
     }
-    default:
-      return void 0;
-  }
+  };
+  return {
+    shape: copyShape(shape),
+    term: a.term,
+    pred: a.pred,
+    conf: a.conf
+  };
 }
-function evalJsonMethod(name, args) {
-  if (name === "stringify") return strPrim("partial");
-  if (name === "parse") return unknown;
-  return void 0;
+function isRelFn(a) {
+  if (!a || typeof a !== "object") return false;
+  if (getFnImpl(a)) return false;
+  const s = a.shape;
+  if (!s || s.k !== "fn") return false;
+  if (s.returnType === void 0) return false;
+  if (s.paramTypes === void 0) return s.params.length === 0;
+  return s.paramTypes.length === s.params.length;
 }
-function evalNumberStatic(name, args) {
-  const a0 = args[0] ? litValue(args[0]) : void 0;
-  switch (name) {
-    case "isInteger":
-      if (typeof a0 === "number") return boolLit(Number.isInteger(a0));
-      return boolPrim();
-    case "isNaN":
-      if (typeof a0 === "number") return boolLit(Number.isNaN(a0));
-      return boolPrim();
-    case "isFinite":
-      if (typeof a0 === "number") return boolLit(Number.isFinite(a0));
-      return boolPrim();
-    case "parseInt":
-    case "parseFloat":
-      if (typeof a0 === "string" || typeof a0 === "number") {
-        const n = name === "parseInt" ? parseInt(String(a0), 10) : parseFloat(String(a0));
-        return numLit(n);
-      }
-      return numPrim();
-    case "MAX_SAFE_INTEGER":
-      return numLit(Number.MAX_SAFE_INTEGER);
-    default:
-      return void 0;
-  }
+function litOfTerm(t) {
+  return t.op === "lit" ? t.value : void 0;
 }
-function evalGlobalFn(name, args) {
-  const a0 = args[0] ? litValue(args[0]) : void 0;
-  switch (name) {
-    case "parseInt":
-      if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseInt(String(a0), 10));
-      return numPrim();
-    case "parseFloat":
-      if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseFloat(String(a0)));
-      return numPrim();
-    case "isNaN":
-      if (typeof a0 === "number") return boolLit(Number.isNaN(a0));
-      return boolPrim();
-    case "Number":
-      if (typeof a0 === "number") return numLit(a0);
-      if (typeof a0 === "string") return numLit(Number(a0));
-      if (typeof a0 === "boolean") return numLit(a0 ? 1 : 0);
-      return numPrim();
-    case "String":
-      if (a0 !== void 0) return strLit(String(a0));
-      return strPrim();
-    case "Boolean":
-      if (a0 !== void 0) return boolLit(Boolean(a0));
-      return boolPrim();
+function foldCompare(op, a, b) {
+  if (a === void 0 || b === void 0) return void 0;
+  if (typeof a !== typeof b) {
+    if (op === "eq") return pFalse;
+    if (op === "ne") return pTrue;
+    return void 0;
+  }
+  switch (op) {
+    case "eq":
+      return a === b ? pTrue : pFalse;
+    case "ne":
+      return a !== b ? pTrue : pFalse;
+    case "lt":
+      return a < b ? pTrue : pFalse;
+    case "le":
+      return a <= b ? pTrue : pFalse;
+    case "gt":
+      return a > b ? pTrue : pFalse;
+    case "ge":
+      return a >= b ? pTrue : pFalse;
     default:
       return void 0;
   }
 }
-function evalArrayStatic(name, args) {
-  const a0 = args[0];
-  switch (name) {
-    case "isArray": {
-      if (!a0) return boolLit(false);
-      const k = a0.shape.k;
-      return boolLit(k === "arr" || k === "tuple");
+function predUsesMappedVars(p, map) {
+  const walkTerm = (t) => {
+    if (t.op === "var") return map.has(t.id);
+    if (t.op === "app") return t.args.some(walkTerm);
+    return false;
+  };
+  const walk = (q) => {
+    switch (q.op) {
+      case "true":
+      case "false":
+        return false;
+      case "eq":
+      case "ne":
+      case "lt":
+      case "le":
+      case "gt":
+      case "ge":
+        return walkTerm(q.a) || walkTerm(q.b);
+      case "and":
+      case "or":
+        return q.args.some(walk);
+      case "not":
+        return walk(q.arg);
+      case "typeof":
+        return walkTerm(q.t);
+    }
+  };
+  return walk(p);
+}
+function mapHasShapeOnlyVar(p, map) {
+  const walkTerm = (t) => {
+    if (t.op === "var") {
+      const arg = map.get(t.id);
+      return !!arg && arg.term === void 0;
+    }
+    if (t.op === "app") return t.args.some(walkTerm);
+    return false;
+  };
+  const walk = (q) => {
+    switch (q.op) {
+      case "true":
+      case "false":
+        return false;
+      case "eq":
+      case "ne":
+      case "lt":
+      case "le":
+      case "gt":
+      case "ge":
+        return walkTerm(q.a) || walkTerm(q.b);
+      case "and":
+      case "or":
+        return q.args.some(walk);
+      case "not":
+        return walk(q.arg);
+      case "typeof":
+        return walkTerm(q.t);
+    }
+  };
+  return walk(p);
+}
+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) => {
+    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 t;
+  };
+  const replaced = substPred(p, substTerm);
+  const fold = (q) => {
+    switch (q.op) {
+      case "true":
+      case "false":
+        return q;
+      case "eq":
+      case "ne":
+      case "lt":
+      case "le":
+      case "gt":
+      case "ge": {
+        const a = litOfTerm(q.a);
+        const b = litOfTerm(q.b);
+        const folded = foldCompare(q.op, a, b);
+        return folded ?? q;
+      }
+      case "and": {
+        const args = q.args.map(fold);
+        if (args.some((x) => x.op === "false")) return pFalse;
+        const rest = args.filter((x) => x.op !== "true");
+        if (rest.length === 0) return pTrue;
+        if (rest.length === 1) return rest[0];
+        return and(...rest);
+      }
+      case "or": {
+        const args = q.args.map(fold);
+        if (args.some((x) => x.op === "true")) return pTrue;
+        const rest = args.filter((x) => x.op !== "false");
+        if (rest.length === 0) return pFalse;
+        if (rest.length === 1) return rest[0];
+        return { op: "or", args: rest };
+      }
+      case "not": {
+        const inner = fold(q.arg);
+        if (inner.op === "true") return pFalse;
+        if (inner.op === "false") return pTrue;
+        return { op: "not", arg: inner };
+      }
+      case "typeof":
+        return q;
     }
-    case "from":
-    case "of":
-      return abs({ k: "arr", element: a0 ?? unknown }, void 0, void 0, "path");
-    default:
-      return void 0;
-  }
-}
-function evalDateCtor(args) {
-  return abs(
-    { k: "brand", name: "Date", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-    void 0,
-    void 0,
-    "path"
-  );
-}
-function evalDateStatic(name, _args) {
-  if (name === "now") return numLit(Date.now());
-  return void 0;
+  };
+  return { pred: fold(replaced), dropped: false };
 }
-function evalDateMethod(name, _recv, _args) {
-  switch (name) {
-    case "getTime":
-    case "valueOf":
-      return numPrim("path");
-    case "toISOString":
-    case "toString":
-      return strPrim("path");
-    default:
-      return void 0;
+function substTermAbs(t, map) {
+  if (t.op === "var") {
+    const arg = map.get(t.id);
+    return arg?.term ?? t;
   }
-}
-function evalRegExpCtor(_args) {
-  return abs(
-    { k: "brand", name: "RegExp", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-    void 0,
-    void 0,
-    "path"
-  );
-}
-function evalRegExpMethod(name, _recv, _args) {
-  switch (name) {
-    case "test":
-      return boolPrim();
-    case "exec":
-      return unknown;
-    default:
-      return void 0;
+  if (t.op === "app") {
+    return simplifyTerm({
+      op: "app",
+      fn: t.fn,
+      args: t.args.map((x) => substTermAbs(x, map))
+    });
   }
+  return t;
 }
-function evalPromiseCtor(_args) {
-  return abs(
-    { k: "eff", eff: "promise", inner: unknown },
-    void 0,
-    void 0,
-    "partial"
-  );
-}
-function evalPromiseStatic(name, args) {
-  switch (name) {
-    case "resolve": {
-      const inner = args[0] ?? unknown;
-      if (inner.shape.k === "eff" && inner.shape.eff === "promise") return inner;
-      return abs({ k: "eff", eff: "promise", inner }, void 0, void 0, "path");
+function substShape(s, map, cache, visiting) {
+  switch (s.k) {
+    case "never":
+    case "any":
+    case "unknown":
+    case "prim":
+      return s;
+    case "brand":
+      return { ...s, shape: substAbsInner(s.shape, map, cache, visiting) };
+    case "eff":
+      return { ...s, inner: substAbsInner(s.inner, map, cache, visiting) };
+    case "arr":
+      return { ...s, element: substAbsInner(s.element, map, cache, visiting) };
+    case "tuple": {
+      const elements = s.elements.map(
+        (e) => substAbsInner(e, map, cache, visiting)
+      );
+      const next = { k: "tuple", elements };
+      if (s.rest) next.rest = substAbsInner(s.rest, map, cache, visiting);
+      return next;
     }
-    case "reject":
-      return abs({ k: "eff", eff: "promise", inner: unknown }, void 0, void 0, "partial");
-    case "all": {
-      const a0 = args[0];
-      if (a0?.shape.k === "arr" && a0.shape.element.shape.k === "eff") {
-        return abs(
-          { k: "eff", eff: "promise", inner: abs({ k: "arr", element: a0.shape.element.shape.inner }, void 0, void 0, "path") },
-          void 0,
-          void 0,
-          "path"
+    case "fn": {
+      const next = { k: "fn", params: s.params };
+      if (s.name !== void 0) next.name = s.name;
+      if (s.paramTypes) {
+        next.paramTypes = s.paramTypes.map(
+          (p) => substAbsInner(p, map, cache, visiting)
         );
       }
-      return abs({ k: "eff", eff: "promise", inner: abs({ k: "arr", element: unknown }, void 0, void 0, "partial") }, void 0, void 0, "partial");
+      if (s.returnType !== void 0) {
+        next.returnType = substAbsInner(s.returnType, map, cache, visiting);
+      }
+      return next;
+    }
+    case "sum":
+      return {
+        ...s,
+        members: s.members.map((m) => substAbsInner(m, map, cache, visiting))
+      };
+    case "obj": {
+      const slots = {};
+      for (const [k, slot] of Object.entries(s.slots)) {
+        const nextSlot = { value: substAbsInner(slot.value, map, cache, visiting) };
+        if (slot.optional) nextSlot.optional = true;
+        if (slot.readonly) nextSlot.readonly = true;
+        slots[k] = nextSlot;
+      }
+      const next = { k: "obj", slots };
+      if (s.index) {
+        next.index = {
+          key: substAbsInner(s.index.key, map, cache, visiting),
+          value: substAbsInner(s.index.value, map, cache, visiting)
+        };
+      }
+      if (s.open) next.open = true;
+      return next;
     }
-    default:
-      return void 0;
   }
 }
-function evalNamespaceCall(ns, method, args) {
-  switch (ns) {
-    case "Math":
-      return evalMathMethod(method, args);
-    case "Object":
-      return evalObjectMethod(method, args);
-    case "JSON":
-      return evalJsonMethod(method, args);
-    case "Number":
-      return evalNumberStatic(method, args);
-    case "Array":
-      return evalArrayStatic(method, args);
-    case "Date":
-      return evalDateStatic(method, args);
-    case "Promise":
-      return evalPromiseStatic(method, args);
-    default:
-      return void 0;
+function substAbsInner(a, map, cache, visiting) {
+  if (a.term?.op === "var" && map.has(a.term.id)) {
+    const repl = map.get(a.term.id);
+    return {
+      shape: repl.shape,
+      term: repl.term,
+      pred: repl.pred,
+      conf: confJoin(a.conf, repl.conf)
+    };
   }
-}
-function evalBuiltinNew(className, args) {
-  switch (className) {
-    case "Date":
-      return evalDateCtor(args);
-    case "RegExp":
-      return evalRegExpCtor(args);
-    case "Promise":
-      return evalPromiseCtor(args);
-    case "Map":
-      return abs(
-        { k: "brand", name: "Map", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-        void 0,
-        void 0,
-        "path"
-      );
-    case "Set":
-      return abs(
-        { k: "brand", name: "Set", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-        void 0,
-        void 0,
-        "path"
-      );
-    default:
-      return void 0;
+  const hit = cache.get(a);
+  if (hit !== void 0) return hit;
+  if (visiting.has(a)) return a;
+  visiting.add(a);
+  const shape = substShape(a.shape, map, cache, visiting);
+  const term = a.term ? substTermAbs(a.term, map) : void 0;
+  let pred = a.pred;
+  let conf = a.conf;
+  if (a.pred) {
+    const r = substPredAbs(a.pred, map);
+    pred = r.pred;
+    if (r.dropped) conf = confJoin(conf, "partial");
   }
+  visiting.delete(a);
+  const result = abs(shape, term, pred, conf);
+  cache.set(a, result);
+  return result;
 }
-function evalBuiltinInstanceMethod(brandName, method, recv, args) {
-  if (brandName === "Date") return evalDateMethod(method, recv, args);
-  if (brandName === "RegExp") return evalRegExpMethod(method, recv, args);
-  if (brandName === "Map") {
-    switch (method) {
-      case "get":
-        return unknown;
-      case "has":
-        return boolPrim();
-      case "set":
-        return recv;
-      case "size":
-        return numPrim("path");
-      default:
-        return void 0;
+function substAbs(a, map) {
+  if (map.size === 0) return a;
+  return substAbsInner(a, map, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+}
+function instantiateReturn(fn, args) {
+  const shape = fn.shape;
+  if (!shape || shape.k !== "fn") return unknown;
+  const src = getFnImpl(fn)?.relation ?? {
+    paramTypes: shape.paramTypes ?? [],
+    returnType: shape.returnType ?? unknown
+  };
+  const map = /* @__PURE__ */ new Map();
+  src.paramTypes.forEach((p, i) => {
+    if (p.term?.op !== "var") return;
+    const id = p.term.id;
+    if (map.has(id)) return;
+    map.set(id, args[i] ?? unknown);
+  });
+  return substAbs(src.returnType, map);
+}
+var applyCallbackHost;
+function setApplyCallbackHost(fn) {
+  applyCallbackHost = fn;
+}
+function applyCallbackAbs(cb, args, env, phi2, budget) {
+  if (!applyCallbackHost) {
+    if (cb && typeof cb === "object" && "shape" in cb) {
+      const a = cb;
+      const impl = getFnImpl(a);
+      if (impl?.relation) return instantiateReturn(a, args);
+      if (isRelFn(a)) return instantiateReturn(a, args);
     }
+    return unknown;
   }
-  if (brandName === "Set") {
-    switch (method) {
-      case "has":
-        return boolPrim();
-      case "add":
-        return recv;
-      case "size":
-        return numPrim("path");
-      default:
-        return void 0;
-    }
+  return applyCallbackHost(cb, args, env, phi2, budget);
+}
+function undefAbs() {
+  return abs(
+    { k: "unknown" },
+    { op: "lit", value: void 0 },
+    pTrue,
+    "exact"
+  );
+}
+function mapElementFallback(cbAbs, elem, out) {
+  if (out.shape.k !== "unknown" || elem.term?.op !== "var") return out;
+  const slot = cbAbs?.shape.k === "fn" ? cbAbs.shape.returnType : void 0;
+  return slot ?? out;
+}
+function projectFlatMapResult(arrConf, mapped) {
+  const flatEls = [];
+  let anyUnknown = false;
+  for (const m of mapped) {
+    if (m.shape.k === "arr") flatEls.push(m.shape.element);
+    else if (m.shape.k === "tuple") flatEls.push(...m.shape.elements);
+    else anyUnknown = true;
   }
+  if (anyUnknown || flatEls.length === 0) return unknown;
+  const first = flatEls[0];
+  const sameIdentity = flatEls.every((e) => {
+    if (e.shape.k !== first.shape.k) return false;
+    if (!e.term && !first.term) return true;
+    if (!e.term || !first.term) return false;
+    return termToString(e.term) === termToString(first.term);
+  });
+  const el = sameIdentity ? first : flatEls.reduce((a, b) => joinAbs(a, b));
+  return abs(
+    { k: "arr", element: el },
+    void 0,
+    void 0,
+    confJoin(arrConf, "path")
+  );
+}
+function asAbs(v2) {
+  if (v2 && typeof v2 === "object" && "shape" in v2) return v2;
   return void 0;
 }
 
@@ -3109,29 +3260,6 @@ function numPrim2(conf = "path") {
 function strArr(conf = "path") {
   return abs({ k: "arr", element: strPrim2("path") }, void 0, void 0, conf);
 }
-function knownPrefix(parts) {
-  let s = "";
-  for (const p of parts) {
-    if (p.term?.op === "lit" && typeof p.term.value === "string") s += p.term.value;
-    else break;
-  }
-  return s;
-}
-function knownSuffix(parts) {
-  let s = "";
-  for (let i = parts.length - 1; i >= 0; i--) {
-    const p = parts[i];
-    if (p.term?.op === "lit" && typeof p.term.value === "string") s = p.term.value + s;
-    else break;
-  }
-  return s;
-}
-function fixedLength(parts) {
-  if (parts.some((p) => !(p.term?.op === "lit" && typeof p.term.value === "string"))) {
-    return void 0;
-  }
-  return parts.reduce((n, p) => n + String(p.term && p.term.op === "lit" ? p.term.value : "").length, 0);
-}
 function isStrRecv(recv) {
   return isTemplateLike(recv) || recv.shape.k === "prim" && recv.shape.type === "string" || recv.term?.op === "lit" && typeof recv.term.value === "string";
 }
@@ -3140,27 +3268,24 @@ function callAbsMethod(recv, name, args) {
   const a0 = args[0] ? litValue(args[0]) : void 0;
   const lit3 = recv.term?.op === "lit" && typeof recv.term.value === "string" ? recv.term.value : void 0;
   if (isTemplateLike(recv)) {
-    const parts = templatePartsOf(recv);
-    const prefix = knownPrefix(parts);
-    const suffix = knownSuffix(parts);
+    const views = absTemplateViews(templatePartsOf(recv));
+    const prefix = knownPrefixOfViews(views);
+    const suffix = knownSuffixOfViews(views);
     switch (name) {
       case "startsWith": {
         if (typeof a0 !== "string") return boolPrim2();
-        if (prefix.length >= a0.length) return boolLit(prefix.startsWith(a0));
-        if (a0.startsWith(prefix)) return boolPrim2();
-        return boolLit(false);
+        const d = decideStartsWith(prefix, a0);
+        return d === "unknown" ? boolPrim2() : boolLit(d);
       }
       case "endsWith": {
         if (typeof a0 !== "string") return boolPrim2();
-        if (suffix.length >= a0.length) return boolLit(suffix.endsWith(a0));
-        if (a0.startsWith(prefix)) return boolPrim2();
-        return boolLit(false);
+        const d = decideEndsWith(suffix, a0);
+        return d === "unknown" ? boolPrim2() : boolLit(d);
       }
       case "includes": {
         if (typeof a0 !== "string") return boolPrim2();
-        const fixed = parts.filter((p) => p.term?.op === "lit" && typeof p.term.value === "string").map((p) => String(p.term && p.term.op === "lit" ? p.term.value : "")).join("");
-        if (fixed.includes(a0)) return boolLit(true);
-        return boolPrim2();
+        const d = decideIncludes(allFixedTextOfViews(views), a0);
+        return d === "unknown" ? boolPrim2() : boolLit(d);
       }
       case "toUpperCase":
       case "toLowerCase":
@@ -3246,8 +3371,7 @@ function callAbsMethod(recv, name, args) {
 function getAbsProperty(recv, name) {
   if (name === "length") {
     if (isTemplateLike(recv)) {
-      const parts = templatePartsOf(recv);
-      const n = fixedLength(parts);
+      const n = fixedLengthOfViews(absTemplateViews(templatePartsOf(recv)));
       if (n !== void 0) return numLit(n);
       return numPrim2("path");
     }
@@ -3563,9 +3687,18 @@ function recordAbsNode(node, value) {
   }
 }
 var absAssignCollector = null;
+var assignFlowDepth = 0;
 function setAbsAssignCollector(collector) {
   absAssignCollector = collector;
 }
+function evalInConditionalFlow(body) {
+  assignFlowDepth++;
+  try {
+    return body();
+  } finally {
+    assignFlowDepth--;
+  }
+}
 function recordAbsAssign(name, prev, next, loc) {
   if (!absAssignCollector) return;
   try {
@@ -3574,7 +3707,8 @@ function recordAbsAssign(name, prev, next, loc) {
       prev,
       next,
       line: loc?.start.line,
-      column: loc?.start.column
+      column: loc?.start.column,
+      conditional: assignFlowDepth > 0
     });
   } catch {
   }
@@ -3952,14 +4086,14 @@ function evalNodeInner(node, env, phi2, budget) {
       }
       if (!m.computed && m.property.type === "Identifier" && obj2.shape.k === "obj") {
         const key = m.property.name;
-        const slot = obj2.shape.slots[key];
+        const slot = getSlot(obj2.shape.slots, key);
         if (slot) return ok2(slot.value, phi2, env);
       }
       if (m.computed) {
         const key = evalNode(m.property, env, phi2, budget).value;
         const kl = litValue(key);
         if (typeof kl === "string" && obj2.shape.k === "obj") {
-          const slot = obj2.shape.slots[kl];
+          const slot = getSlot(obj2.shape.slots, kl);
           if (slot) return ok2(slot.value, phi2, env);
         }
         if (typeof kl === "number") {
@@ -4011,11 +4145,11 @@ function evalNodeInner(node, env, phi2, budget) {
       if (els.length === 0) {
         return ok2(abs({ k: "arr", element: unknown }, void 0, void 0, "exact"), phi2, env);
       }
-      if (els.length <= 8) {
+      if (!shouldWidenArrayLiteral(els.length)) {
         return ok2(abs({ k: "tuple", elements: els }, void 0, void 0, "exact"), phi2, env);
       }
       const elem = els.reduce((x, y) => joinAbs(x, y));
-      return ok2(abs({ k: "arr", element: elem }, void 0, void 0, "path"), phi2, env);
+      return ok2(abs({ k: "arr", element: elem }, void 0, void 0, widenedArrayConf()), phi2, env);
     }
     default:
       return ok2(unknown, phi2, env);
@@ -4535,7 +4669,7 @@ function evalFor(node, env, phi2, budget) {
       const lv = litValue(t.value);
       if (lv === false || lv === null || lv === void 0) break;
     }
-    const bodyR = evalNode(node.body, local, phi2, budget);
+    const bodyR = evalInConditionalFlow(() => evalNode(node.body, local, phi2, budget));
     if (bodyR.returned) return bodyR;
     if (bodyR.threw) return bodyR;
     if (bodyR.brk) {
@@ -4558,7 +4692,7 @@ function evalWhile(node, env, phi2, budget) {
     const t = evalNode(node.test, local, phi2, budget);
     const lv = litValue(t.value);
     if (lv === false || lv === null || lv === void 0) break;
-    const bodyR = evalNode(node.body, local, phi2, budget);
+    const bodyR = evalInConditionalFlow(() => evalNode(node.body, local, phi2, budget));
     if (bodyR.returned || bodyR.threw) return bodyR;
     if (bodyR.brk) {
       local = bodyR.env;
@@ -4573,7 +4707,7 @@ function evalDoWhile(node, env, phi2, budget) {
   let local = env;
   let acc = unknown;
   for (let i = 0; i < MAX_LOOP_ITERS; i++) {
-    const bodyR = evalNode(node.body, local, phi2, budget);
+    const bodyR = evalInConditionalFlow(() => evalNode(node.body, local, phi2, budget));
     if (bodyR.returned || bodyR.threw) return bodyR;
     if (bodyR.brk) {
       local = bodyR.env;
@@ -4610,7 +4744,7 @@ function evalForOf(node, env, phi2, budget) {
   const n = Math.min(elements.length, MAX_LOOP_ITERS);
   for (let i = 0; i < n; i++) {
     local = withVar(local, bindName, elements[i]);
-    const bodyR = evalNode(node.body, local, phi2, budget);
+    const bodyR = evalInConditionalFlow(() => evalNode(node.body, local, phi2, budget));
     if (bodyR.returned || bodyR.threw) return bodyR;
     if (bodyR.brk) {
       local = bodyR.env;
@@ -4661,6 +4795,7 @@ function evalVarDecl(node, env, phi2, budget) {
   for (const d of node.declarations) {
     if (d.id.type !== "Identifier" || !d.init) continue;
     const r = evalNode(d.init, local, phi2, budget);
+    recordAbsNode(d.id, r.value);
     local = withVar(local, d.id.name, r.value);
   }
   return { value: unknown, phi: phi2, env: local };
@@ -4668,8 +4803,15 @@ function evalVarDecl(node, env, phi2, budget) {
 function evalIf(node, env, phi2, budget) {
   const t = evalNode(node.test, env, phi2, budget).value;
   const tv = litValue(t);
+  const refineEnv = (branch) => {
+    const m = matchRelIdentLit(node.test);
+    if (!m || branch !== "true") return env;
+    const cur = env.vars.get(m.name);
+    if (!cur) return env;
+    return withVar(env, m.name, refineAbsForRelTrue(cur, m.op, m.k));
+  };
   if (tv === true) {
-    return evalNode(node.consequent, env, phi2, budget);
+    return evalNode(node.consequent, refineEnv("true"), phi2, budget);
   }
   if (tv === false) {
     if (node.alternate) return evalNode(node.alternate, env, phi2, budget);
@@ -4677,9 +4819,15 @@ function evalIf(node, env, phi2, budget) {
   }
   const tCons = trueConstraint(t);
   const fCons = falseConstraint(t);
-  const a = evalNode(node.consequent, env, tCons ? and(phi2, tCons) : phi2, budget);
-  if (node.alternate) {
-    const b = evalNode(node.alternate, env, fCons ? and(phi2, fCons) : phi2, budget);
+  const envT = refineEnv("true");
+  const a = evalInConditionalFlow(
+    () => evalNode(node.consequent, envT, tCons ? and(phi2, tCons) : phi2, budget)
+  );
+  const alt = node.alternate;
+  if (alt) {
+    const b = evalInConditionalFlow(
+      () => evalNode(alt, env, fCons ? and(phi2, fCons) : phi2, budget)
+    );
     return { value: joinAbs(a.value, b.value), phi: phi2, env, returned: a.returned || b.returned };
   }
   if (a.returned || a.threw) {
@@ -4814,6 +4962,15 @@ function $call(fn, args) {
 
 // src/algebra/exec/calls.ts
 var bCallCollector = null;
+var GLOBAL_FNS = /* @__PURE__ */ new Set([
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "Number",
+  "String",
+  "Boolean"
+]);
 function setBCallCollector(collector) {
   bCallCollector = collector;
 }
@@ -4832,7 +4989,8 @@ function $callNamed(name, fn, args, loc, argLocs) {
   if (loc) pushCallLoc({ line: loc[0], column: loc[1] });
   try {
     if (typeof fn === "function") {
-      result = fn(...args);
+      const g = GLOBAL_FNS.has(name) && fn === globalThis[name] ? evalGlobalFn(name, args) : void 0;
+      result = g ?? fn(...args);
     } else if (fn && typeof fn === "object" && "shape" in fn) {
       result = $call(fn, args);
     }
@@ -4955,12 +5113,32 @@ function litAbsFromJs(v2) {
   }
   return unknown;
 }
+function litTruth(a) {
+  if (a.term?.op === "lit") {
+    return Boolean(a.term.value);
+  }
+  switch (a.shape.k) {
+    case "obj":
+    case "arr":
+    case "tuple":
+    case "fn":
+    case "brand":
+    case "eff":
+      return true;
+    case "prim":
+      return a.shape.type === "symbol" || a.shape.type === "bigint" ? true : void 0;
+    case "never":
+      return false;
+    default:
+      return void 0;
+  }
+}
 function isDefinitelyTrue(a) {
-  return litValue(a) === true;
+  return litTruth(a) === true;
 }
 function isDefinitelyFalse(a) {
-  const lv = litValue(a);
-  if (lv === false) return true;
+  const t = litTruth(a);
+  if (t === false) return true;
   if (a.shape.k === "never") return true;
   return false;
 }
@@ -5013,8 +5191,19 @@ function $for(init, test, step, body, maxIters = DEFAULT_MAX_LOOP_ITERS) {
   }
   return exitJoin ? joinAbs(exitJoin, state) : state;
 }
+function tupleOrWiden(els, conf) {
+  if (shouldWidenArrayLiteral(els.length)) {
+    return abs(
+      { k: "arr", element: els.reduce((x, y) => joinAbs(x, y)) },
+      void 0,
+      void 0,
+      widenedArrayConf()
+    );
+  }
+  return abs({ k: "tuple", elements: els }, void 0, void 0, conf);
+}
 function $arr(items) {
-  return abs({ k: "tuple", elements: items.map(asAbsVal) }, void 0, void 0, "exact");
+  return tupleOrWiden(items.map(asAbsVal), "exact");
 }
 function $idx(a, i) {
   const iv = litValue(i);
@@ -5031,17 +5220,31 @@ function $idx(a, i) {
   if (a.shape.k === "sum") {
     return a.shape.members.map((m) => $idx(m, i)).reduce((x, y) => joinAbs(x, y));
   }
+  const sv = litValue(a);
+  if (typeof sv === "string") {
+    if (typeof iv === "number" && Number.isInteger(iv)) {
+      if (iv >= 0 && iv < sv.length) {
+        return abs(
+          { k: "prim", type: "string" },
+          { op: "lit", value: sv[iv] },
+          pTrue,
+          "exact"
+        );
+      }
+      return undef();
+    }
+    return unknown;
+  }
   return unknown;
 }
 function $idxSet(a, i, value) {
   const iv = litValue(i);
-  if (a.shape.k === "tuple" && typeof iv === "number" && Number.isInteger(iv)) {
+  if (a.shape.k === "tuple" && typeof iv === "number" && Number.isInteger(iv) && iv >= 0) {
     const els = [...a.shape.elements];
-    if (iv >= 0 && iv < els.length) {
-      els[iv] = asAbsVal(value);
-      const next = abs({ k: "tuple", elements: els }, void 0, void 0, a.conf);
-      return next;
-    }
+    while (els.length < iv) els.push(undef());
+    els[iv] = asAbsVal(value);
+    const next = abs({ k: "tuple", elements: els }, void 0, void 0, a.conf);
+    return next;
   }
   return a;
 }
@@ -5057,6 +5260,15 @@ function $len(a) {
   if (a.shape.k === "arr") {
     return abs({ k: "prim", type: "number" }, void 0, void 0, "path");
   }
+  const sv = litValue(a);
+  if (typeof sv === "string") {
+    return abs(
+      { k: "prim", type: "number" },
+      { op: "lit", value: sv.length },
+      pTrue,
+      "exact"
+    );
+  }
   return unknown;
 }
 function $obj(slots) {
@@ -5070,33 +5282,33 @@ function $spread(a, b) {
 function $concat(a, b) {
   a = asAbsVal(a);
   b = asAbsVal(b);
-  if (a.shape.k === "tuple" && b.shape.k === "tuple") {
-    return abs(
-      { k: "tuple", elements: [...a.shape.elements, ...b.shape.elements] },
-      void 0,
-      void 0,
-      confJoin(a.conf, b.conf)
-    );
+  const as = a.shape;
+  const bs = b.shape;
+  if (as.k === "tuple" && bs.k === "tuple") {
+    return tupleOrWiden([...as.elements, ...bs.elements], confJoin(a.conf, b.conf));
+  }
+  if (as.k === "arr" || bs.k === "arr") {
+    const ea = as.k === "tuple" ? as.elements.reduce((x, y) => joinAbs(x, y)) : as.k === "arr" ? as.element : a;
+    const eb = bs.k === "tuple" ? bs.elements.reduce((x, y) => joinAbs(x, y)) : bs.k === "arr" ? bs.element : b;
+    return abs({ k: "arr", element: joinAbs(ea, eb) }, void 0, void 0, "path");
   }
-  if (a.shape.k === "tuple" && b.shape.k !== "tuple") {
+  if (as.k === "tuple") {
     return abs(
-      { k: "tuple", elements: [...a.shape.elements, b] },
+      { k: "tuple", elements: [...as.elements, b] },
       void 0,
       void 0,
       confJoin(a.conf, b.conf)
     );
   }
-  if (a.shape.k !== "tuple" && b.shape.k === "tuple") {
+  if (bs.k === "tuple") {
     return abs(
-      { k: "tuple", elements: [a, ...b.shape.elements] },
+      { k: "tuple", elements: [a, ...bs.elements] },
       void 0,
       void 0,
       confJoin(a.conf, b.conf)
     );
   }
-  const ea = a.shape.k === "arr" ? a.shape.element : a;
-  const eb = b.shape.k === "arr" ? b.shape.element : b;
-  return abs({ k: "arr", element: joinAbs(ea, eb) }, void 0, void 0, "path");
+  return abs({ k: "arr", element: joinAbs(a, b) }, void 0, void 0, "path");
 }
 function $elems(a) {
   if (a.shape.k === "tuple") return [...a.shape.elements];
@@ -5116,7 +5328,52 @@ function $forOf(iterable, body, maxIters = DEFAULT_MAX_LOOP_ITERS) {
     ));
   }
 }
+function namespaceNameOf(v2) {
+  if (typeof v2 !== "object" && typeof v2 !== "function") return void 0;
+  if (v2 === Math) return "Math";
+  if (v2 === Number) return "Number";
+  if (v2 === JSON) return "JSON";
+  if (v2 === Object) return "Object";
+  if (v2 === Array) return "Array";
+  if (v2 === Date) return "Date";
+  if (v2 === Promise) return "Promise";
+  return void 0;
+}
+function $regex(pattern, flags = "") {
+  const litStr = (v2) => abs({ k: "prim", type: "string" }, { op: "lit", value: v2 }, pTrue, "exact");
+  return abs(
+    {
+      k: "brand",
+      name: "RegExp",
+      shape: objOf({
+        source: { value: litStr(pattern) },
+        flags: { value: litStr(flags) }
+      })
+    },
+    void 0,
+    void 0,
+    "exact"
+  );
+}
 function $get(o, key, opts) {
+  if (!o || typeof o !== "object" || !("shape" in o)) {
+    const ns = namespaceNameOf(o);
+    if (ns) {
+      try {
+        const raw = o[key];
+        if (typeof raw === "function") {
+          return absFunction([`${ns}.${key}`], {
+            body: noBody,
+            apply: (args) => evalNamespaceCall(ns, key, args) ?? unknown
+          });
+        }
+        return $lit(raw);
+      } catch {
+        return unknown;
+      }
+    }
+    return unknown;
+  }
   if (o.shape.k === "brand") return $get(o.shape.shape, key, opts);
   if (isObj(o)) {
     const slot = o.shape.slots[key];
@@ -5302,6 +5559,77 @@ var BIN_OPS = {
   "===": "$eq",
   "!==": "$ne"
 };
+var COMPOUND_OPS = {
+  "+=": "$add",
+  "-=": "$sub",
+  "*=": "$mul",
+  "/=": "$div",
+  "%=": "$mod"
+};
+function memberPathOf(m, opts) {
+  const layers = [];
+  let cur = m;
+  let rootSrc = null;
+  while (cur.type === "MemberExpression") {
+    const mm = cur;
+    const k = mm.property;
+    if (mm.computed) {
+      if (k.type === "NumericLiteral") {
+        const key = `$lit(${k.value})`;
+        layers.unshift({
+          get: (b) => `$idx(${b}, ${key})`,
+          set: (b, v2) => `$idxSet(${b}, ${key}, ${v2})`
+        });
+      } else if (k.type === "StringLiteral") {
+        const key = JSON.stringify(k.value);
+        layers.unshift({
+          get: (b) => `$get(${b}, ${key})`,
+          set: (b, v2) => `$set(${b}, ${key}, ${v2})`
+        });
+      } else if (isExpression(k)) {
+        const key = transpileExpression(k, opts);
+        layers.unshift({
+          get: (b) => `$idx(${b}, ${key})`,
+          set: (b, v2) => `$idxSet(${b}, ${key}, ${v2})`
+        });
+      } else {
+        return null;
+      }
+    } else if (k.type === "Identifier") {
+      const key = JSON.stringify(k.name);
+      layers.unshift({
+        get: (b) => `$get(${b}, ${key})`,
+        set: (b, v2) => `$set(${b}, ${key}, ${v2})`
+      });
+    } else {
+      return null;
+    }
+    cur = mm.object;
+  }
+  if (cur.type === "Identifier") {
+    rootSrc = cur.name;
+  } else if (cur.type === "ThisExpression" && opts.thisParam) {
+    rootSrc = opts.thisParam;
+  } else {
+    return null;
+  }
+  return { rootSrc, layers };
+}
+function readPathSrc(p) {
+  return p.layers.reduce((acc, l) => l.get(acc), p.rootSrc);
+}
+function setPathSrc(p, valSrc) {
+  let acc = valSrc;
+  for (let i = p.layers.length - 1; i >= 0; i--) {
+    const l = p.layers[i];
+    const base = i === 0 ? p.rootSrc : readPrefix(p, i - 1);
+    acc = l.set(base, acc);
+  }
+  return acc;
+}
+function readPrefix(p, j) {
+  return p.layers.slice(0, j + 1).reduce((acc, l) => l.get(acc), p.rootSrc);
+}
 function transpileSource(source, opts = {}) {
   const file = parseSource(source);
   return transpileFile(file, { ...opts, source: opts.source ?? source });
@@ -5310,7 +5638,7 @@ function transpileFile(file, opts = {}) {
   const runtime = opts.runtimeImport ?? "@nudojs/core/exec";
   const lines = [
     `// nudo B-path transpile \u2014 values are Abs; operators are overloaded calls`,
-    `import { $add, $sub, $mul, $div, $mod, $neg, $typeof, $not, $eq, $ne, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $while, $whileSeq, $arr, $idx, $idxSet, $len, $call, $throw, $class, $new, $invoke, $invokeSuper, $super, $async, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal } from ${JSON.stringify(runtime)};`,
+    `import { $add, $sub, $mul, $div, $mod, $neg, $typeof, $not, $eq, $ne, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $while, $whileSeq, $arr, $idx, $idxSet, $len, $call, $throw, $class, $new, $invoke, $invokeSuper, $super, $async, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal, $regex } from ${JSON.stringify(runtime)};`,
     ``
   ];
   for (const stmt of file.program.body) {
@@ -5329,34 +5657,24 @@ function stmtReturns(stmt) {
   }
   return false;
 }
-function stmtAlwaysExits(stmt) {
-  return stmtReturns(stmt) && stmt.type !== "ExpressionStatement";
-}
-function foldEarlyReturns(stmts) {
-  for (let i = stmts.length - 2; i >= 0; i--) {
+function transpileFnBodyStmts(stmts, depth, opts) {
+  for (let i = 0; i < stmts.length; i++) {
     const stmt = stmts[i];
     if (stmt.type !== "IfStatement" || stmt.alternate != null) continue;
     if (!stmtReturns(stmt.consequent)) continue;
-    const tail = stmts.slice(i + 1);
-    if (tail.length === 0 || !tail.every(stmtAlwaysExits)) continue;
-    const alt = {
-      type: "BlockStatement",
-      body: tail,
-      directives: [],
-      start: stmt.consequent.start,
-      end: stmt.consequent.end,
-      loc: stmt.consequent.loc
-    };
-    const rewritten = {
-      ...stmt,
-      alternate: alt
-    };
-    return foldEarlyReturns([...stmts.slice(0, i), rewritten]);
-  }
-  return stmts;
-}
-function transpileFnBodyStmts(stmts, depth, opts) {
-  return foldEarlyReturns(stmts).map((s) => transpileStatement(s, depth, opts)).join("\n");
+    const rest = stmts.slice(i + 1);
+    if (rest.length === 0) continue;
+    const head = stmts.slice(0, i).map((s) => transpileStatement(s, depth, opts)).join("\n");
+    const test = transpileExpression(stmt.test, opts);
+    const cons = transpileBlockAsThunk(stmt.consequent, depth, opts);
+    const altBody = transpileFnBodyStmts(rest, depth + 1, opts);
+    const promoted = `${indent(depth)}return $fork(${test}, ${cons}, () => {
+${altBody}
+${indent(depth)}});`;
+    return head ? `${head}
+${promoted}` : promoted;
+  }
+  return stmts.map((s) => transpileStatement(s, depth, opts)).join("\n");
 }
 function emitDestructure(pattern, fromSrc, kw, pad, opts, out, tmpSeq) {
   if (pattern.type === "Identifier") {
@@ -5422,13 +5740,55 @@ function emitDestructure(pattern, fromSrc, kw, pad, opts, out, tmpSeq) {
     });
   }
 }
+function emitParamBinding(params, pad, opts) {
+  const sig = [];
+  const prologue = [];
+  let rest;
+  params.forEach((p, i) => {
+    if (p.type === "Identifier") {
+      sig.push(p.name);
+      return;
+    }
+    if (p.type === "RestElement") {
+      if (p.argument.type === "Identifier") {
+        rest = p.argument.name;
+        return;
+      }
+      const ph2 = `_rest${i}`;
+      rest = ph2;
+      emitDestructure(p.argument, ph2, "const", pad, opts, prologue, { n: 0 });
+      return;
+    }
+    const ph = `_p${i}`;
+    sig.push(ph);
+    if (p.type === "AssignmentPattern") {
+      const def = transpileExpression(p.right, opts);
+      if (p.left.type === "Identifier") {
+        prologue.push(`${pad}const ${p.left.name} = $orDefault(${ph}, () => ${def});`);
+      } else {
+        const t = `_pd${i}`;
+        prologue.push(`${pad}const ${t} = $orDefault(${ph}, () => ${def});`);
+        emitDestructure(p.left, t, "const", pad, opts, prologue, { n: 0 });
+      }
+      return;
+    }
+    if (p.type === "ObjectPattern" || p.type === "ArrayPattern") {
+      emitDestructure(p, ph, "const", pad, opts, prologue, { n: 0 });
+    }
+  });
+  return { sig, rest, prologue };
+}
 function transpileStatement(stmt, depth, opts) {
   const pad = indent(depth);
   switch (stmt.type) {
     case "ExportNamedDeclaration": {
       const decl = stmt.declaration;
       if (!decl) return `${pad}/* export specifiers skipped */`;
-      return transpileStatement(decl, depth, opts);
+      const inner = transpileStatement(decl, depth, opts);
+      if (depth === 0 && decl.type === "VariableDeclaration" && !pad) {
+        return `export ${inner}`;
+      }
+      return inner;
     }
     case "ImportDeclaration": {
       const specs = stmt.specifiers.map((s) => {
@@ -5455,19 +5815,16 @@ function transpileStatement(stmt, depth, opts) {
     }
     case "FunctionDeclaration": {
       if (!stmt.id) return `${pad}// <anonymous fn skipped>`;
-      const paramParts = stmt.params.map((p) => {
-        if (p.type === "Identifier") return { kind: "id", name: p.name };
-        if (p.type === "RestElement" && p.argument.type === "Identifier") {
-          return { kind: "rest", name: p.argument.name };
-        }
-        return { kind: "id", name: "_" };
-      });
-      const named = paramParts.filter((p) => p.kind === "id" && p.name !== "_").map((p) => p.name);
-      const rest = paramParts.find((p) => p.kind === "rest");
-      const paramsSig = rest ? [...named, `...${rest.name}`] : named;
+      const { sig, rest, prologue } = emitParamBinding(
+        stmt.params,
+        indent(depth + 2),
+        opts
+      );
+      const named = sig;
+      const paramsSig = rest ? [...named, `...${rest}`] : named;
       const params = paramsSig.join(", ");
-      const bodyStmts = stmt.body.type === "BlockStatement" ? transpileFnBodyStmts(stmt.body.body, depth + 2, opts) : `${indent(depth + 2)}return ${transpileExpression(stmt.body, opts)};`;
-      const restBind = rest ? `${indent(depth + 1)}const ${rest.name} = arguments.length > ${named.length} ? $arr(Array.from(arguments).slice(${named.length})) : $arr([]);
+      const bodyStmts = stmt.body.type === "BlockStatement" ? [...prologue, transpileFnBodyStmts(stmt.body.body, depth + 2, opts)].join("\n") : `${indent(depth + 2)}return ${transpileExpression(stmt.body, opts)};`;
+      const restBind = rest ? `${indent(depth + 1)}const ${rest} = arguments.length > ${named.length} ? $arr(Array.from(arguments).slice(${named.length})) : $arr([]);
 ` : "";
       if (stmt.generator) {
         return [
@@ -5509,7 +5866,7 @@ function transpileStatement(stmt, depth, opts) {
     case "ExpressionStatement":
       return `${pad}${transpileExpression(stmt.expression, opts)};`;
     case "VariableDeclaration": {
-      const kw = stmt.kind === "const" ? "const" : "let";
+      const kw = "let";
       const asVar = matchAsOverride(stmt, opts);
       const lines = [];
       let tmpSeq = 0;
@@ -5562,7 +5919,7 @@ function transpileStatement(stmt, depth, opts) {
       ].join("\n");
     }
     case "BlockStatement":
-      return stmt.body.map((s) => transpileStatement(s, depth, opts)).join("\n");
+      return transpileFnBodyStmts(stmt.body, depth, opts);
     case "SwitchStatement": {
       const disc = transpileExpression(stmt.discriminant, opts);
       const arms = [];
@@ -5822,6 +6179,15 @@ function transpileExpression(expr, opts = {}) {
       const r = transpileExpression(expr.right, opts);
       return op === "&&" ? `$fork(${l}, () => ${r}, () => ${l})` : `$fork(${l}, () => ${l}, () => ${r})`;
     }
+    case "ConditionalExpression": {
+      const test = transpileExpression(expr.test, opts);
+      const c = transpileExpression(expr.consequent, opts);
+      const a = transpileExpression(expr.alternate, opts);
+      return `$fork(${test}, () => ${c}, () => ${a})`;
+    }
+    case "RegExpLiteral": {
+      return `$regex(${JSON.stringify(expr.pattern)}${expr.flags ? `, ${JSON.stringify(expr.flags)}` : ""})`;
+    }
     case "BinaryExpression": {
       const fn = BIN_OPS[expr.operator];
       if (!fn) return `/* unsupported ${expr.operator} */ $lit(undefined)`;
@@ -5837,6 +6203,14 @@ function transpileExpression(expr, opts = {}) {
       if (expr.operator === "+") return arg;
       return `/* unary ${expr.operator} */ $lit(undefined)`;
     }
+    case "UpdateExpression": {
+      const arg = expr.argument;
+      if (arg.type === "Identifier") {
+        const fn = expr.operator === "++" ? "$add" : "$sub";
+        return `${arg.name} = ${fn}(${arg.name}, $lit(1))`;
+      }
+      return `/* update ${expr.operator} */ $lit(undefined)`;
+    }
     case "AwaitExpression": {
       const arg = transpileExpression(expr.argument, opts);
       return `$await(${arg})`;
@@ -5938,19 +6312,23 @@ function transpileExpression(expr, opts = {}) {
       return acc ?? `$arr([])`;
     }
     case "AssignmentExpression": {
-      if (expr.operator !== "=") return `/* assign ${expr.operator} */ $lit(undefined)`;
+      const compoundFn = COMPOUND_OPS[expr.operator];
       const right = transpileExpression(expr.right, opts);
       if (expr.left.type === "MemberExpression") {
-        if (!expr.left.computed && expr.left.object.type === "ThisExpression" && expr.left.property.type === "Identifier" && opts.thisParam) {
-          return `${opts.thisParam} = $set(${opts.thisParam}, ${JSON.stringify(expr.left.property.name)}, ${right})`;
+        const m = expr.left;
+        const path = memberPathOf(m, opts);
+        if (path) {
+          const valSrc = compoundFn ? `${compoundFn}(${readPathSrc(path)}, ${right})` : right;
+          const writeSrc = setPathSrc(path, valSrc);
+          return `${path.rootSrc} = ${writeSrc}`;
         }
-        if (!expr.left.computed && expr.left.property.type === "Identifier") {
-          const obj2 = transpileExpression(expr.left.object, opts);
-          return `$set(${obj2}, ${JSON.stringify(expr.left.property.name)}, ${right})`;
+        if (!m.computed && m.property.type === "Identifier") {
+          const obj2 = transpileExpression(m.object, opts);
+          return `$set(${obj2}, ${JSON.stringify(m.property.name)}, ${right})`;
         }
-        if (expr.left.computed) {
-          const obj2 = transpileExpression(expr.left.object, opts);
-          const k = expr.left.property;
+        if (m.computed) {
+          const obj2 = transpileExpression(m.object, opts);
+          const k = m.property;
           if (k.type === "NumericLiteral") {
             return `$idxSet(${obj2}, $lit(${k.value}), ${right})`;
           }
@@ -5961,11 +6339,15 @@ function transpileExpression(expr, opts = {}) {
             return `$idxSet(${obj2}, ${transpileExpression(k, opts)}, ${right})`;
           }
         }
+        return `/* assign */ $lit(undefined)`;
       }
       if (expr.left.type === "Identifier") {
+        if (compoundFn) {
+          return `${expr.left.name} = ${compoundFn}(${expr.left.name}, ${right})`;
+        }
         return `${expr.left.name} = ${right}`;
       }
-      return `/* assign */ $lit(undefined)`;
+      return compoundFn ? `/* assign ${expr.operator} */ $lit(undefined)` : `/* assign */ $lit(undefined)`;
     }
     case "CallExpression":
     case "OptionalCallExpression": {
@@ -6020,16 +6402,11 @@ function transpileExpression(expr, opts = {}) {
     case "ArrowFunctionExpression":
     case "FunctionExpression": {
       const fn = expr;
-      const paramParts = fn.params.map((p) => {
-        if (p.type === "Identifier") return p.name;
-        if (p.type === "RestElement" && p.argument?.type === "Identifier") {
-          return `...${p.argument.name}`;
-        }
-        return "_p";
-      });
-      const nameList = `[${paramParts.map((p) => JSON.stringify(p.startsWith("...") ? p.slice(3) : p)).join(", ")}]`;
+      const { sig, rest, prologue } = emitParamBinding(fn.params, indent(1), opts);
+      const paramParts = rest ? [...sig, `...${rest}`] : sig;
+      const nameList = `[${sig.map((p) => JSON.stringify(p)).join(", ")}]`;
       if (fn.body.type === "BlockStatement") {
-        const inner = transpileFnBodyStmts(fn.body.body, 1, opts);
+        const inner = [...prologue, transpileFnBodyStmts(fn.body.body, 1, opts)].join("\n");
         if (fn.async) {
           return `$fnVal(${nameList}, (${paramParts.join(", ")}) => $async(() => {
 ${inner}
@@ -6040,6 +6417,13 @@ ${inner}
 })`;
       }
       const bodySrc = transpileExpression(fn.body, opts);
+      if (prologue.length > 0) {
+        const thunk = fn.async ? `$async(() => ${bodySrc})` : bodySrc;
+        return `$fnVal(${nameList}, (${paramParts.join(", ")}) => {
+${prologue.join("\n")}
+  return ${thunk};
+})`;
+      }
       if (fn.async) {
         return `$fnVal(${nameList}, (${paramParts.join(", ")}) => $async(() => ${bodySrc}))`;
       }
@@ -6128,6 +6512,21 @@ function findCtor(startName) {
 }
 function $new(cls, args) {
   if (typeof cls === "function") {
+    if (cls === Array) {
+      if (args.length === 1) {
+        const n = litValue(args[0]);
+        if (typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= 4096) {
+          const els = Array.from({ length: n }, () => undefAbs());
+          return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
+        }
+        return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
+      }
+      return abs({ k: "tuple", elements: args.map((a) => asAbs(a) ?? unknown) }, void 0, void 0, "exact");
+    }
+    if (cls === RegExp) {
+      const p = args[0] ? litValue(args[0]) : void 0;
+      if (typeof p === "string") return $regex(p, args[1] ? String(litValue(args[1]) ?? "") : "");
+    }
     const name = cls.name || "Object";
     const shape = objOf({});
     return abs({ k: "brand", name, shape }, void 0, void 0, "path");
@@ -6168,12 +6567,82 @@ function $super(thisVal, childName, args) {
   }
   return after ?? thisVal;
 }
+function execRegexBrand(re, method, args) {
+  if (re.shape.k !== "brand" || re.shape.name !== "RegExp") return void 0;
+  if (method !== "exec" && method !== "test" && method !== "toString") return void 0;
+  const inner = re.shape.shape;
+  const patAbs = inner.shape.k === "obj" ? inner.shape.slots["source"]?.value : void 0;
+  const flagsAbs = inner.shape.k === "obj" ? inner.shape.slots["flags"]?.value : void 0;
+  const pat = patAbs ? litValue(patAbs) : void 0;
+  if (typeof pat !== "string") return void 0;
+  const flagsV = flagsAbs ? litValue(flagsAbs) : void 0;
+  const flags = typeof flagsV === "string" ? flagsV : "";
+  if (method === "toString") return strLit(`/${pat}/${flags}`);
+  const subject = args[0] ? litValue(args[0]) : void 0;
+  if (typeof subject !== "string") {
+    return method === "test" ? abs({ k: "prim", type: "boolean" }, void 0, void 0, "partial") : void 0;
+  }
+  let reReal;
+  try {
+    reReal = new RegExp(pat, flags);
+  } catch {
+    return void 0;
+  }
+  const m = reReal.exec(subject);
+  if (method === "test") return boolLit(reReal.test(subject));
+  if (!m) {
+    return abs({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
+  }
+  const els = m.map((g) => g === void 0 ? undefAbs() : strLit(g));
+  return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
+}
+function stringRegexMethod(recv, method, args) {
+  if (method !== "match" && method !== "search") return void 0;
+  const re = args[0];
+  if (!re || re.shape.k !== "brand" || re.shape.name !== "RegExp") return void 0;
+  const inner = re.shape.shape;
+  const patAbs = inner.shape.k === "obj" ? inner.shape.slots["source"]?.value : void 0;
+  const flagsAbs = inner.shape.k === "obj" ? inner.shape.slots["flags"]?.value : void 0;
+  const pat = patAbs ? litValue(patAbs) : void 0;
+  const sv = litValue(recv);
+  if (typeof pat !== "string" || typeof sv !== "string") return void 0;
+  const flagsV = flagsAbs ? litValue(flagsAbs) : void 0;
+  const flags = typeof flagsV === "string" ? flagsV : "";
+  let reReal;
+  try {
+    reReal = new RegExp(pat, flags);
+  } catch {
+    return void 0;
+  }
+  if (method === "search") {
+    const idx = sv.search(reReal);
+    return abs({ k: "prim", type: "number" }, { op: "lit", value: idx }, void 0, "exact");
+  }
+  if (flags.includes("g")) {
+    const all = sv.match(reReal) ?? [];
+    return abs({ k: "tuple", elements: all.map((s) => strLit(s)) }, void 0, void 0, "exact");
+  }
+  const m = reReal.exec(sv);
+  if (!m) {
+    return abs({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
+  }
+  const els = m.map((g) => g === void 0 ? undefAbs() : strLit(g));
+  return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
+}
 function $invoke(thisVal, method, args, loc) {
+  if (!thisVal || typeof thisVal !== "object" || !("shape" in thisVal)) {
+    const ns = namespaceNameOf(thisVal);
+    return (ns ? evalNamespaceCall(ns, method, args) : void 0) ?? unknown;
+  }
   if (thisVal.shape.k === "sum") {
     const results = thisVal.shape.members.filter((m) => memberLikelyHasMethod(m, method)).map((m) => $invoke(m, method, args, loc));
     if (results.length === 0) return unknown;
     return results.reduce((a, b) => joinAbs(a, b));
   }
+  {
+    const reR = execRegexBrand(thisVal, method, args);
+    if (reR !== void 0) return reR;
+  }
   const brandName = thisVal.shape.k === "brand" ? thisVal.shape.name : void 0;
   if (brandName) {
     const m = findMethod(brandName, method);
@@ -6186,6 +6655,10 @@ function $invoke(thisVal, method, args, loc) {
     const arrR = invokeArrMethod(thisVal, method, args);
     if (arrR !== void 0) return arrR;
   }
+  {
+    const sm = stringRegexMethod(thisVal, method, args);
+    if (sm !== void 0) return sm;
+  }
   {
     const viaTable = callAbsMethod(thisVal, method, args);
     if (viaTable) return viaTable;
@@ -6280,6 +6753,18 @@ function invokeArrMethod(arr, method, args) {
   if (method === "join") {
     return abs({ k: "prim", type: "string" }, void 0, void 0, "path");
   }
+  if (method === "fill" && args.length >= 1) {
+    const v2 = asAbs(args[0]) ?? unknown;
+    if (shape.k === "tuple") {
+      return abs(
+        { k: "tuple", elements: shape.elements.map(() => v2) },
+        void 0,
+        void 0,
+        confJoin(arr.conf, v2.conf)
+      );
+    }
+    return abs({ k: "arr", element: v2 }, void 0, void 0, confJoin(arr.conf, v2.conf));
+  }
   if (method === "includes") {
     return abs({ k: "prim", type: "boolean" }, void 0, void 0, "partial");
   }
@@ -6328,6 +6813,7 @@ function $thisSet(thisVal, key, value) {
   return unknown;
 }
 function $orDefault(v2, dflt) {
+  if (v2 === void 0) return asAbsVal(dflt());
   if (litValue(v2) === void 0 && v2.shape.k !== "never") {
     if (v2.term?.op === "lit" && v2.term.value === void 0) return asAbsVal(dflt());
     if (v2.shape.k === "unknown" && v2.term?.op === "lit") return asAbsVal(dflt());
@@ -6382,7 +6868,7 @@ var RUNTIME_IMPORT_RE = /^import\s*\{[^}]+\}\s*from\s*"[^"]+";\s*$/m;
 function rewriteUserImports(js) {
   js = js.replace(
     /^import\s*\{\s*\*\s+as\s+([A-Za-z_$][\w$]*)\s*\}\s*from\s*["']([^"']+)["'];\s*$/gm,
-    (_all, local, spec) => `const ${local} = __nudoBindNamespace(${JSON.stringify(spec)});`
+    (_all, local, spec) => `let ${local} = __nudoBindNamespace(${JSON.stringify(spec)});`
   );
   js = js.replace(
     /^import\s*["']([^"']+)["'];\s*$/gm,
@@ -6395,7 +6881,7 @@ function rewriteUserImports(js) {
       return parts.map((p) => {
         const [imported, local] = p.split(/\s+as\s+/).map((x) => x.trim());
         const bind = local ?? imported;
-        return `const ${bind} = __nudoBindImport(${JSON.stringify(spec)}, ${JSON.stringify(imported)});`;
+        return `let ${bind} = __nudoBindImport(${JSON.stringify(spec)}, ${JSON.stringify(imported)});`;
       }).join("\n");
     }
   );
@@ -6540,8 +7026,8 @@ ${js}`;
   }
   const exportFns = [...js.matchAll(/^export function (\w+)/gm)].map((m) => m[1]);
   js = js.replace(/^export function /gm, "function ");
-  const exportConsts = [...js.matchAll(/^export const (\w+)/gm)].map((m) => m[1]);
-  js = js.replace(/^export const /gm, "const ");
+  const exportConsts = [...js.matchAll(/^export (?:const|let) (\w+)/gm)].map((m) => m[1]);
+  js = js.replace(/^export (?:const|let) /gm, "let ");
   const names = [.../* @__PURE__ */ new Set([...exportFns, ...exportConsts])];
   const argNames = [
     ...runtimeArgNames(),
@@ -6595,6 +7081,17 @@ function callTranspiledExportFull(exports, name, args) {
     }
   }
   if (isAbsVal(fn)) {
+    if (fn.shape.k === "fn") {
+      try {
+        const r = $call(fn, args);
+        return { result: r, throws: never };
+      } catch (e) {
+        if (isNudoThrow(e)) {
+          return { result: never, throws: e.absValue };
+        }
+        return { result: unknown, throws: never };
+      }
+    }
     return { result: fn, throws: never };
   }
   return { result: unknown, throws: never };
@@ -6604,10 +7101,6 @@ function callTranspiledExport(exports, name, args) {
 }
 
 export {
-  stripTypes,
-  resetParseSourceCache,
-  getParseSourceCacheSize,
-  parseSource,
   lit,
   v,
   app,
@@ -6657,6 +7150,26 @@ export {
   isStrPrim,
   isExactLit,
   litValue,
+  viewTemplateParts,
+  knownPrefixOfViews,
+  knownSuffixOfViews,
+  allFixedTextOfViews,
+  fixedLengthOfViews,
+  formatTemplateNameViews,
+  mergeAdjacentFixedViews,
+  templateMatchesValue,
+  decideStartsWith,
+  decideEndsWith,
+  decideIncludes,
+  absTemplateViews,
+  templatePartsOf,
+  createTemplateAbs,
+  isTemplateLike,
+  concatString,
+  stripTypes,
+  resetParseSourceCache,
+  getParseSourceCacheSize,
+  parseSource,
   attachFnImpl,
   getFnImpl,
   absFunction,
@@ -6665,11 +7178,11 @@ export {
   shapeOnlyFn,
   objOf,
   isObj,
+  getSlot,
   spread,
   joinObjects,
   joinValues,
   makeSum,
-  collapseToOptional,
   fnOf,
   joinFunctions,
   joinAbs,
@@ -6692,18 +7205,15 @@ export {
   mapElementFallback,
   projectFlatMapResult,
   asAbs,
-  templatePartsOf,
-  createTemplateAbs,
-  isTemplateLike,
-  concatString,
   add,
-  numericBounds,
   sub,
   mul,
   div,
   mod,
   cmp,
   trueConstraint,
+  refineAbsForRelTrue,
+  matchRelIdentLit,
   falseConstraint,
   typeofAbs,
   negAbs,
@@ -6805,6 +7315,7 @@ export {
   asAbsVal,
   $fnVal,
   $lit,
+  litTruth,
   isDefinitelyTrue,
   isDefinitelyFalse,
   $fork,
@@ -6820,6 +7331,8 @@ export {
   $concat,
   $elems,
   $forOf,
+  namespaceNameOf,
+  $regex,
   $get,
   $set,
   $while,