@nudojs/core 0.4.0 → 1.0.0

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

@@ -703,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";
 }
@@ -712,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;
@@ -719,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);
@@ -793,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);
@@ -1220,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) {
@@ -1258,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;
@@ -1450,169 +1719,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 };
+// src/algebra/containers.ts
+var TUPLE_LITERAL_CAP = 8;
+function shouldWidenArrayLiteral(n) {
+  return n > TUPLE_LITERAL_CAP;
 }
-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);
+function widenedArrayConf() {
+  return "path";
 }
 
 // src/algebra/language.ts
@@ -1728,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;
@@ -1918,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}`);
@@ -2164,9 +2277,29 @@ function evalArrayStatic(name, args) {
       const k = a0.shape.k;
       return boolLit(k === "arr" || k === "tuple");
     }
-    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;
   }
@@ -2518,10 +2651,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 +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";
 }
@@ -3158,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":
@@ -3264,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");
     }
@@ -3581,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 {
@@ -3592,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 {
   }
@@ -3970,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") {
@@ -4029,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);
@@ -4553,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) {
@@ -4576,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;
@@ -4591,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;
@@ -4628,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;
@@ -4687,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);
@@ -4696,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) {
@@ -5062,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);
@@ -5142,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];
@@ -6961,10 +7101,6 @@ function callTranspiledExport(exports, name, args) {
 }
 
 export {
-  stripTypes,
-  resetParseSourceCache,
-  getParseSourceCacheSize,
-  parseSource,
   lit,
   v,
   app,
@@ -7014,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,
@@ -7022,11 +7178,11 @@ export {
   shapeOnlyFn,
   objOf,
   isObj,
+  getSlot,
   spread,
   joinObjects,
   joinValues,
   makeSum,
-  collapseToOptional,
   fnOf,
   joinFunctions,
   joinAbs,
@@ -7049,18 +7205,15 @@ export {
   mapElementFallback,
   projectFlatMapResult,
   asAbs,
-  templatePartsOf,
-  createTemplateAbs,
-  isTemplateLike,
-  concatString,
   add,
-  numericBounds,
   sub,
   mul,
   div,
   mod,
   cmp,
   trueConstraint,
+  refineAbsForRelTrue,
+  matchRelIdentLit,
   falseConstraint,
   typeofAbs,
   negAbs,