@nudojs/core 0.4.0 → 1.0.1

package/dist/{chunk-N7E2A7IK.js → chunk-P3G2TODS.js}

@@ -309,11 +309,18 @@ var phiAnd = and;
 function implies(phi2, pred) {
   if (pred.op === "true") return true;
   if (pred.op === "false") return false;
+  if (phi2.op === "false") return true;
+  if (predEquals(phi2, pred)) return true;
+  if (phi2.op === "and" && phi2.args.some((c) => predEquals(c, pred))) return true;
+  if (phi2.op === "or") {
+    return phi2.args.every((a) => implies(a, pred));
+  }
+  if (pred.op === "or") {
+    return pred.args.some((b) => implies(phi2, b));
+  }
   if (phi2.op === "true") {
     return decideLiteralPred(pred) === true;
   }
-  if (predEquals(phi2, pred)) return true;
-  if (phi2.op === "and" && phi2.args.some((c) => predEquals(c, pred))) return true;
   const bounds = extractBounds(phi2);
   const implied = impliesViaBounds(pred, bounds);
   if (implied !== void 0) return implied;
@@ -703,6 +710,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";
 }
@@ -712,6 +799,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;
@@ -719,29 +813,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);
@@ -793,6 +876,324 @@ function coerceToStringParts(a) {
   return void 0;
 }
 
+// src/algebra/derivation.ts
+var collector = null;
+var nextId = 1;
+var byAbs = /* @__PURE__ */ new WeakMap();
+var sessionNodes = null;
+function setDerivationCollector(fn) {
+  collector = fn;
+}
+function hasDerivationSession() {
+  return sessionNodes !== null;
+}
+function beginDerivationSession() {
+  sessionNodes = /* @__PURE__ */ new Map();
+  nextId = 1;
+}
+function endDerivationSession() {
+  const nodes = sessionNodes ? [...sessionNodes.values()] : [];
+  sessionNodes = null;
+  collector = null;
+  return nodes;
+}
+function abortDerivationSession() {
+  sessionNodes = null;
+  collector = null;
+}
+function note(node) {
+  const full = { ...node, id: nextId++ };
+  if (sessionNodes) sessionNodes.set(full.id, full);
+  collector?.(full);
+  return full;
+}
+function tagDerivationRoot(abs2, meta) {
+  const node = note({
+    kind: "root",
+    expr: meta.expr,
+    ...meta.importFrom !== void 0 ? { importFrom: meta.importFrom } : {},
+    ...meta.importName !== void 0 ? { importName: meta.importName } : {},
+    parents: []
+  });
+  byAbs.set(abs2, node);
+  return node;
+}
+function getDerivation(abs2) {
+  return byAbs.get(abs2);
+}
+function setDerivation(abs2, node) {
+  byAbs.set(abs2, node);
+}
+function derivationChain(node) {
+  const chain = [node];
+  const seen = /* @__PURE__ */ new Set([node.id]);
+  let cur = node;
+  while (cur.kind !== "root" && cur.parents.length > 0) {
+    const pid = cur.parents[0];
+    if (seen.has(pid) || !sessionNodes) break;
+    const parent = sessionNodes.get(pid);
+    if (!parent) break;
+    seen.add(pid);
+    chain.push(parent);
+    cur = parent;
+  }
+  return chain;
+}
+function noteDerivationAdd(a, b, result) {
+  if (!sessionNodes) return;
+  const vb = litValue(b);
+  const va = litValue(a);
+  let parent;
+  let offset;
+  if (typeof vb === "number" && Number.isFinite(vb)) {
+    parent = byAbs.get(a);
+    offset = vb;
+  } else if (typeof va === "number" && Number.isFinite(va)) {
+    parent = byAbs.get(b);
+    offset = va;
+  }
+  if (!parent || offset === void 0) return;
+  const node = note({
+    kind: "shift",
+    offset,
+    parents: [parent.id]
+  });
+  byAbs.set(result, node);
+}
+function noteDerivationJoin(inputs, result) {
+  if (!sessionNodes) return;
+  const parents = [];
+  for (const a of inputs) {
+    const n = byAbs.get(a);
+    if (n && !parents.includes(n.id)) parents.push(n.id);
+  }
+  if (parents.length === 0) return;
+  const node = note({ kind: "join", parents });
+  byAbs.set(result, node);
+}
+function projectDerivationDsl(node, localName) {
+  const chain = derivationChain(node);
+  const root = chain[chain.length - 1];
+  if (!root || root.kind !== "root" || root.expr === void 0) return void 0;
+  if (chain.some((n) => n.kind === "join" || n.kind === "opaque")) return void 0;
+  const shifts = [];
+  for (let i = chain.length - 2; i >= 0; i--) {
+    const n = chain[i];
+    if (n.kind !== "shift" || n.offset === void 0) return void 0;
+    shifts.push(n.offset);
+  }
+  const rootExpr = root.expr;
+  const imports = [];
+  if (root.importFrom !== void 0) {
+    imports.push({
+      name: root.importName ?? rootExpr,
+      from: root.importFrom
+    });
+  }
+  if (shifts.length === 0) {
+    return { prelude: [], expr: rootExpr, imports };
+  }
+  let current = rootExpr;
+  const prelude = [];
+  for (let i = 0; i < shifts.length; i++) {
+    const step = `${current}.shift(${shifts[i]})`;
+    if (i === shifts.length - 1) {
+      prelude.push(`const ${localName} = ${step};`);
+      return { prelude, expr: localName, imports };
+    }
+    const tmp = `${localName}_${i}`;
+    prelude.push(`const ${tmp} = ${step};`);
+    current = tmp;
+  }
+  return void 0;
+}
+function termKey3(t) {
+  return t === void 0 ? "<none>" : termToString(t);
+}
+
+// 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 = absShapeKey(x);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(x);
+  }
+  return deduped;
+}
+function absShapeKey(a, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(a)) return "cycle";
+  seen.add(a);
+  try {
+    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 === "arr") return `arr(${absShapeKey(s.element, seen)})`;
+    if (s.k === "tuple") {
+      const els = s.elements.map((e) => absShapeKey(e, seen)).join(",");
+      const rest = s.rest ? `...${absShapeKey(s.rest, seen)}` : "";
+      return `tuple[${els}${rest}]`;
+    }
+    if (s.k === "brand") return `brand:${s.name}(${absShapeKey(s.shape, seen)})`;
+    if (s.k === "eff") return `eff:${s.eff}<${absShapeKey(s.inner, seen)}>`;
+    if (s.k === "obj") {
+      const slots = Object.keys(s.slots).sort().map((k) => {
+        const slot = s.slots[k];
+        const flags = (slot.optional ? "?" : "") + (slot.readonly ? "r" : "");
+        return `${k}${flags}:${absShapeKey(slot.value, seen)}`;
+      }).join(",");
+      const idx = s.index ? `idx(${absShapeKey(s.index.key, seen)}\u2192${absShapeKey(s.index.value, seen)})` : "";
+      const open = s.open ? "open" : "";
+      return `obj{${slots}}${idx}${open}`;
+    }
+    if (s.k === "fn") {
+      const pts = (s.paramTypes ?? []).map((t) => absShapeKey(t, seen)).join(",");
+      const ret = s.returnType ? absShapeKey(s.returnType, seen) : "?";
+      const name = s.name ? `#${s.name}` : "";
+      return `fn${name}(${s.params.join(",")}|${pts})=>${ret}`;
+    }
+    if (s.k === "sum") {
+      return `sum(${s.members.map((m) => absShapeKey(m, seen)).join("|")})`;
+    }
+    return "other";
+  } finally {
+    seen.delete(a);
+  }
+}
+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);
+  const result = joinValues(a, b);
+  noteDerivationJoin([a, b], result);
+  return result;
+}
+
 // src/algebra/arithmetic.ts
 function add(a, b, phi2 = pTrue) {
   const va = litValue(a);
@@ -815,7 +1216,9 @@ function add(a, b, phi2 = pTrue) {
     const term = simplifyTerm(app("+", [a.term, b.term]));
     const pred = addPred(a, b, term, phi2);
     const conf = term.op === "lit" ? "exact" : confJoin(confJoin(a.conf, b.conf), "path");
-    return abs({ k: "prim", type: "number" }, term, pred, conf);
+    const result = abs({ k: "prim", type: "number" }, term, pred, conf);
+    noteDerivationAdd(a, b, result);
+    return result;
   }
   if (isAnyLike(a) || isAnyLike(b)) {
     const term = a.term && b.term ? simplifyTerm(app("+", [a.term, b.term])) : void 0;
@@ -854,7 +1257,7 @@ function dedupAbsMembers(ms) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const m of ms) {
-    const key = m.shape.k === "prim" ? `prim:${m.shape.type}` : m.shape.k === "sum" ? `sum:${m.shape.members.length}` : m.shape.k;
+    const key = absShapeKey(m);
     if (seen.has(key)) continue;
     seen.add(key);
     out.push(m);
@@ -934,7 +1337,7 @@ function collectBoundsFromPred(pred, term, acc) {
     }
     if (p.op === "gt" && match(p.a) && p.b.op === "lit" && typeof p.b.value === "number") {
       const n = p.b.value;
-      if (acc.lo === void 0 || n > acc.lo.value || n === acc.lo.value && p.op === "gt") {
+      if (acc.lo === void 0 || n > acc.lo.value || n === acc.lo.value && !acc.lo.strict) {
         acc.lo = { value: n, strict: true };
       }
       return;
@@ -948,7 +1351,7 @@ function collectBoundsFromPred(pred, term, acc) {
     }
     if (p.op === "lt" && match(p.a) && p.b.op === "lit" && typeof p.b.value === "number") {
       const n = p.b.value;
-      if (acc.hi === void 0 || n < acc.hi.value) {
+      if (acc.hi === void 0 || n < acc.hi.value || n === acc.hi.value && !acc.hi.strict) {
         acc.hi = { value: n, strict: true };
       }
       return;
@@ -967,7 +1370,7 @@ function collectBoundsFromPhi(phi2, id, acc) {
   for (const p of conjs) {
     if (p.op === "gt" && p.a.op === "var" && p.a.id === id && p.b.op === "lit" && typeof p.b.value === "number") {
       const n = p.b.value;
-      if (acc.lo === void 0 || n > acc.lo.value) {
+      if (acc.lo === void 0 || n > acc.lo.value || n === acc.lo.value && !acc.lo.strict) {
         acc.lo = { value: n, strict: true };
       }
     }
@@ -979,7 +1382,7 @@ function collectBoundsFromPhi(phi2, id, acc) {
     }
     if (p.op === "lt" && p.a.op === "var" && p.a.id === id && p.b.op === "lit" && typeof p.b.value === "number") {
       const n = p.b.value;
-      if (acc.hi === void 0 || n < acc.hi.value) {
+      if (acc.hi === void 0 || n < acc.hi.value || n === acc.hi.value && !acc.hi.strict) {
         acc.hi = { value: n, strict: true };
       }
     }
@@ -1220,6 +1623,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) {
@@ -1258,6 +1675,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;
@@ -1371,7 +1816,7 @@ function flipBounds(pred, src, dst, out) {
     if (p.op !== "gt" && p.op !== "ge" && p.op !== "lt" && p.op !== "le") {
       return;
     }
-    if (termKey3(p.a) !== termKey3(src)) return;
+    if (termKey4(p.a) !== termKey4(src)) return;
     if (p.b.op !== "lit" || typeof p.b.value !== "number") return;
     const n = p.b.value;
     if (p.op === "gt") out.push(lt(dst, lit(-n)));
@@ -1381,7 +1826,7 @@ function flipBounds(pred, src, dst, out) {
   };
   apply(pred);
 }
-function termKey3(t) {
+function termKey4(t) {
   if (t.op === "lit") return `lit:${JSON.stringify(t.value)}`;
   if (t.op === "var") return `var:${t.id}`;
   return `app:${t.fn}`;
@@ -1450,169 +1895,13 @@ 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" };
-}
-function isObj(a) {
-  return a.shape.k === "obj";
-}
-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;
+// src/algebra/containers.ts
+var TUPLE_LITERAL_CAP = 8;
+function shouldWidenArrayLiteral(n) {
+  return n > TUPLE_LITERAL_CAP;
 }
-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);
+function widenedArrayConf() {
+  return "path";
 }
 
 // src/algebra/language.ts
@@ -1728,8 +2017,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;
@@ -1918,7 +2207,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}`);
@@ -2025,6 +2314,8 @@ function evalMathMethod(name, args) {
     case "round":
       if (typeof a0 === "number") return numLit(Math.round(a0));
       return numPrim();
+    case "random":
+      return numPrim("path");
     case "sqrt":
       if (typeof a0 === "number") return numLit(Math.sqrt(a0));
       return numPrim();
@@ -2104,6 +2395,12 @@ function evalJsonMethod(name, args) {
   if (name === "parse") return unknown;
   return void 0;
 }
+function foldParseInt(s, radix) {
+  const str2 = String(s);
+  if (radix === void 0) return numLit(parseInt(str2));
+  if (!Number.isInteger(radix) || radix < 2 || radix > 36) return numLit(NaN);
+  return numLit(parseInt(str2, radix));
+}
 function evalNumberStatic(name, args) {
   const a0 = args[0] ? litValue(args[0]) : void 0;
   switch (name) {
@@ -2117,12 +2414,16 @@ function evalNumberStatic(name, args) {
       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);
+        const radix = args[1] ? litValue(args[1]) : void 0;
+        if (radix === void 0) return foldParseInt(a0, void 0);
+        if (typeof radix === "number") return foldParseInt(a0, radix);
+        return numPrim();
       }
       return numPrim();
+    case "parseFloat":
+      if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseFloat(String(a0)));
+      return numPrim();
     case "MAX_SAFE_INTEGER":
       return numLit(Number.MAX_SAFE_INTEGER);
     default:
@@ -2133,7 +2434,12 @@ 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));
+      if (typeof a0 === "string" || typeof a0 === "number") {
+        const radix = args[1] ? litValue(args[1]) : void 0;
+        if (radix === void 0) return foldParseInt(a0, void 0);
+        if (typeof radix === "number") return foldParseInt(a0, radix);
+        return numPrim();
+      }
       return numPrim();
     case "parseFloat":
       if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseFloat(String(a0)));
@@ -2156,17 +2462,44 @@ function evalGlobalFn(name, args) {
       return void 0;
   }
 }
+function peelBrand(shape) {
+  let s = shape;
+  while (s.k === "brand") s = s.shape.shape;
+  return s;
+}
 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");
+      const s = peelBrand(a0.shape);
+      if (s.k === "arr" || s.k === "tuple") return boolLit(true);
+      if (s.k === "any" || s.k === "unknown" || s.k === "sum") return boolPrim();
+      return boolLit(false);
     }
-    case "from":
     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;
   }
@@ -2180,7 +2513,7 @@ function evalDateCtor(args) {
   );
 }
 function evalDateStatic(name, _args) {
-  if (name === "now") return numLit(Date.now());
+  if (name === "now") return numPrim("path");
   return void 0;
 }
 function evalDateMethod(name, _recv, _args) {
@@ -2518,10 +2851,10 @@ function parseUncached(source, opts) {
     attachComment: true,
     errorRecovery: opts?.errorRecovery === true
   });
-  return stripTypes(ast);
+  return opts?.keepTs === true ? ast : stripTypes(ast);
 }
 function parseSource(source, opts) {
-  if (opts?.errorRecovery === true) {
+  if (opts?.keepTs === true || opts?.errorRecovery === true) {
     return parseUncached(source, opts);
   }
   if (source.length > MAX_AST_SOURCE_CHARS) {
@@ -3127,29 +3460,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";
 }
@@ -3158,27 +3468,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":
@@ -3248,7 +3555,7 @@ function callAbsMethod(recv, name, args) {
           const parts = lit3.split(sep).map((s) => strLit(s));
           return abs({ k: "tuple", elements: parts }, void 0, void 0, "exact");
         }
-        return abs({ k: "tuple", elements: [strLit(lit3)] }, void 0, void 0, "path");
+        return strArr("path");
       }
       return strArr("path");
     }
@@ -3264,8 +3571,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");
     }
@@ -3534,8 +3840,8 @@ function callBudgetKey(kind, id, args) {
   return `${kind}|${id}|${parts.join(",")}`;
 }
 var absTruncCollector = null;
-function setAbsTruncationCollector(collector) {
-  absTruncCollector = collector;
+function setAbsTruncationCollector(collector2) {
+  absTruncCollector = collector2;
 }
 function noteTruncation(label) {
   if (!absTruncCollector) return;
@@ -3559,8 +3865,10 @@ function exitCall() {
   _activeCallKeys.pop();
 }
 var absCallCollector = null;
-function setAbsCallCollector(collector) {
-  absCallCollector = collector;
+function setAbsCallCollector(collector2) {
+  const prev = absCallCollector;
+  absCallCollector = collector2;
+  return prev;
 }
 function recordAbsCall(fnName, args, result, callLoc, threw) {
   if (!absCallCollector) return;
@@ -3570,8 +3878,8 @@ function recordAbsCall(fnName, args, result, callLoc, threw) {
   }
 }
 var absNodeCollector = null;
-function setAbsNodeCollector(collector) {
-  absNodeCollector = collector;
+function setAbsNodeCollector(collector2) {
+  absNodeCollector = collector2;
 }
 function recordAbsNode(node, value) {
   if (!absNodeCollector || !value) return;
@@ -3581,8 +3889,17 @@ function recordAbsNode(node, value) {
   }
 }
 var absAssignCollector = null;
-function setAbsAssignCollector(collector) {
-  absAssignCollector = collector;
+var assignFlowDepth = 0;
+function setAbsAssignCollector(collector2) {
+  absAssignCollector = collector2;
+}
+function evalInConditionalFlow(body) {
+  assignFlowDepth++;
+  try {
+    return body();
+  } finally {
+    assignFlowDepth--;
+  }
 }
 function recordAbsAssign(name, prev, next, loc) {
   if (!absAssignCollector) return;
@@ -3592,7 +3909,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 {
   }
@@ -3602,6 +3920,16 @@ function evalSource(source, entry, opts = {}) {
   const file = opts.file ?? parseSource(source);
   const env = emptyEnv();
   let phi2 = opts.phi ?? pTrue;
+  if (opts.seedVars) {
+    for (const [k, v2] of Object.entries(opts.seedVars)) {
+      env.vars.set(k, v2);
+    }
+  }
+  if (opts.seedFns) {
+    for (const [k, fn] of Object.entries(opts.seedFns)) {
+      env.fns.set(k, fn);
+    }
+  }
   if (opts.modules) {
     for (const stmt of file.program.body) {
       if (stmt.type === "ImportDeclaration") {
@@ -3635,8 +3963,13 @@ function evalSource(source, entry, opts = {}) {
       }
     }
   }
-  const value = callFunction(env, entry.fn, entry.args, phi2, opts.budget);
-  return { value, phi: phi2, env };
+  const full = callFunctionFull(env, entry.fn, entry.args, phi2, opts.budget);
+  return {
+    value: full.result,
+    phi: phi2,
+    env,
+    ...full.throws.shape.k !== "never" ? { threw: true, ...full.throwLoc ? { throwLoc: full.throwLoc } : {} } : {}
+  };
 }
 function registerClassDecl(env, node) {
   const cls = node;
@@ -3692,6 +4025,37 @@ function registerFunction(env, decl) {
     async: decl.async === true
   });
 }
+function callFunctionFull(env, name, args, phi2 = pTrue, budget = defaultLeakBudget) {
+  const fn = env.fns.get(name);
+  const neverAbs = abs({ k: "never" }, void 0, void 0, "exact");
+  if (!fn) return { result: unknown, throws: neverAbs };
+  const key = callBudgetKey("fn", name, args);
+  if (!enterCall(key, name)) {
+    return { result: truncatedAbs(), throws: neverAbs };
+  }
+  try {
+    let local = { vars: new Map(env.vars), fns: env.fns, hofCollect: env.hofCollect };
+    const cls = env.classes;
+    if (cls) local.classes = cls;
+    fn.params.forEach((p, i) => {
+      local.vars.set(p, args[i] ?? unknown);
+    });
+    const result = evalNode(fn.body, local, phi2, budget);
+    if (result.threw) {
+      return {
+        result: neverAbs,
+        throws: result.value,
+        ...result.throwLoc ? { throwLoc: result.throwLoc } : {}
+      };
+    }
+    if (fn.async) {
+      return { result: coerceAsyncReturn(result.value), throws: neverAbs };
+    }
+    return { result: result.value, throws: neverAbs };
+  } finally {
+    exitCall();
+  }
+}
 function callFunction(env, name, args, phi2 = pTrue, budget = defaultLeakBudget) {
   const fn = env.fns.get(name);
   if (!fn) return unknown;
@@ -3858,7 +4222,18 @@ function evalNodeInner(node, env, phi2, budget) {
     case "ThrowStatement": {
       const arg = node.argument;
       const v2 = arg ? evalNode(arg, env, phi2, budget).value : unknown;
-      return { value: v2, phi: phi2, env, threw: true };
+      const loc = node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0;
+      return { value: v2, phi: phi2, env, threw: true, ...loc ? { throwLoc: loc } : {} };
+    }
+    case "ConditionalExpression": {
+      const cond = node;
+      const t = evalNode(cond.test, env, phi2, budget).value;
+      const tv = litValue(t);
+      if (tv === true) return evalNode(cond.consequent, env, phi2, budget);
+      if (tv === false) return evalNode(cond.alternate, env, phi2, budget);
+      const a = evalNode(cond.consequent, env, phi2, budget);
+      const b = evalNode(cond.alternate, env, phi2, budget);
+      return { value: joinAbs(a.value, b.value), phi: phi2, env };
     }
     case "ForStatement":
       return evalFor(node, env, phi2, budget);
@@ -3970,14 +4345,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") {
@@ -4029,11 +4404,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);
@@ -4309,18 +4684,27 @@ function evalCall(node, env, phi2, budget) {
         }
         if (obj2.shape.k === "tuple") {
           const kept = [];
-          for (const el of obj2.shape.elements) {
-            const p = applyUnaryCallback(fnNode, el, env, phi2, budget);
+          let anyUncertain = false;
+          for (const el2 of obj2.shape.elements) {
+            const p = applyUnaryCallback(fnNode, el2, env, phi2, budget);
             const lv = litValue(p);
             if (lv === false) continue;
-            kept.push(el);
+            if (lv !== true) anyUncertain = true;
+            kept.push(el2);
           }
           if (kept.length === 0) {
             return ok2(abs({ k: "arr", element: unknown }, void 0, void 0, "path"), phi2, env);
           }
-          if (kept.length === 1) return ok2(kept[0], phi2, env);
+          if (!anyUncertain) {
+            return ok2(
+              abs({ k: "tuple", elements: kept }, void 0, void 0, confJoin(obj2.conf, "path")),
+              phi2,
+              env
+            );
+          }
+          const el = kept.reduce((a, b) => joinAbs(a, b));
           return ok2(
-            abs({ k: "tuple", elements: kept }, void 0, void 0, confJoin(obj2.conf, "path")),
+            abs({ k: "arr", element: el }, void 0, void 0, confJoin(obj2.conf, "path")),
             phi2,
             env
           );
@@ -4531,7 +4915,16 @@ function evalBlock(node, env, phi2, budget) {
       pendingPartial = void 0;
     }
     if (r.returned || r.brk || r.cont || r.threw) {
-      return { value: last, phi: curPhi, env: local, returned: r.returned, brk: r.brk, cont: r.cont, threw: r.threw };
+      return {
+        value: last,
+        phi: curPhi,
+        env: local,
+        returned: r.returned,
+        brk: r.brk,
+        cont: r.cont,
+        threw: r.threw,
+        ...r.throwLoc ? { throwLoc: r.throwLoc } : {}
+      };
     }
   }
   if (pendingPartial !== void 0) {
@@ -4553,7 +4946,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) {
@@ -4576,7 +4969,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;
@@ -4591,7 +4984,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;
@@ -4628,7 +5021,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;
@@ -4687,8 +5080,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);
@@ -4696,9 +5096,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) {
@@ -4709,6 +5115,20 @@ function evalIf(node, env, phi2, budget) {
 function analyzeFn(source, fnName, args, phi2 = pTrue, budget, file, modules) {
   return evalSource(source, { fn: fnName, args }, { phi: phi2, budget, file, modules }).value;
 }
+function analyzeFnFull(source, fnName, args, opts = {}) {
+  const r = evalSource(source, { fn: fnName, args }, opts);
+  if (r.threw) {
+    return {
+      result: abs({ k: "never" }, void 0, void 0, "exact"),
+      throws: r.value,
+      ...r.throwLoc ? { throwLoc: r.throwLoc } : {}
+    };
+  }
+  return {
+    result: r.value,
+    throws: abs({ k: "never" }, void 0, void 0, "exact")
+  };
+}
 function evalProgramAbs(source, opts = {}) {
   resetAbsCallBudget();
   const file = opts.file ?? parseSource(source);
@@ -4842,8 +5262,8 @@ var GLOBAL_FNS = /* @__PURE__ */ new Set([
   "String",
   "Boolean"
 ]);
-function setBCallCollector(collector) {
-  bCallCollector = collector;
+function setBCallCollector(collector2) {
+  bCallCollector = collector2;
 }
 function getBCallCollector() {
   return bCallCollector;
@@ -5062,8 +5482,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);
@@ -5142,33 +5573,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];
@@ -6585,6 +7016,10 @@ function invokeArrMethod(arr, method, args) {
     return acc;
   }
   if (method === "filter" && args[0]) {
+    if (shape.k === "tuple") {
+      const el = shape.elements.length > 0 ? shape.elements.reduce((a, b) => joinAbs(a, b)) : unknown;
+      return abs({ k: "arr", element: el }, void 0, void 0, confJoin(arr.conf, "path"));
+    }
     return arr;
   }
   if (method === "flatMap" && args[0]) {
@@ -6961,10 +7396,6 @@ function callTranspiledExport(exports, name, args) {
 }
 
 export {
-  stripTypes,
-  resetParseSourceCache,
-  getParseSourceCacheSize,
-  parseSource,
   lit,
   v,
   app,
@@ -7014,19 +7445,37 @@ export {
   isStrPrim,
   isExactLit,
   litValue,
+  stripTypes,
+  resetParseSourceCache,
+  getParseSourceCacheSize,
+  parseSource,
   attachFnImpl,
   getFnImpl,
   absFunction,
   relationFingerprint,
   relationFn,
   shapeOnlyFn,
+  setDerivationCollector,
+  hasDerivationSession,
+  beginDerivationSession,
+  endDerivationSession,
+  abortDerivationSession,
+  tagDerivationRoot,
+  getDerivation,
+  setDerivation,
+  derivationChain,
+  noteDerivationAdd,
+  noteDerivationJoin,
+  projectDerivationDsl,
+  termKey3 as termKey,
   objOf,
   isObj,
+  getSlot,
   spread,
   joinObjects,
   joinValues,
   makeSum,
-  collapseToOptional,
+  absShapeKey,
   fnOf,
   joinFunctions,
   joinAbs,
@@ -7049,18 +7498,31 @@ export {
   mapElementFallback,
   projectFlatMapResult,
   asAbs,
+  viewTemplateParts,
+  knownPrefixOfViews,
+  knownSuffixOfViews,
+  allFixedTextOfViews,
+  fixedLengthOfViews,
+  formatTemplateNameViews,
+  mergeAdjacentFixedViews,
+  templateMatchesValue,
+  decideStartsWith,
+  decideEndsWith,
+  decideIncludes,
+  absTemplateViews,
   templatePartsOf,
   createTemplateAbs,
   isTemplateLike,
   concatString,
   add,
-  numericBounds,
   sub,
   mul,
   div,
   mod,
   cmp,
   trueConstraint,
+  refineAbsForRelTrue,
+  matchRelIdentLit,
   falseConstraint,
   typeofAbs,
   negAbs,
@@ -7130,11 +7592,13 @@ export {
   setAbsNodeCollector,
   setAbsAssignCollector,
   evalSource,
+  callFunctionFull,
   callFunction,
   evalMethodBody,
   evalNode,
   applyAbsFn,
   analyzeFn,
+  analyzeFnFull,
   evalProgramAbs,
   collectAbsNodeTypes,
   findAbsAtPosition,