@nudojs/core 1.0.0 → 1.0.1

package/dist/{chunk-RZOQL6PT.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;
@@ -869,6 +876,141 @@ 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 };
@@ -970,29 +1112,59 @@ function flattenSum(xs) {
   const seen = /* @__PURE__ */ new Set();
   const deduped = [];
   for (const x of out) {
-    const key = shapeKey(x);
+    const key = absShapeKey(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}`;
+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);
   }
-  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 };
@@ -1017,7 +1189,9 @@ function joinAbs(a, 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);
+  const result = joinValues(a, b);
+  noteDerivationJoin([a, b], result);
+  return result;
 }
 
 // src/algebra/arithmetic.ts
@@ -1042,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;
@@ -1081,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);
@@ -1161,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;
@@ -1175,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;
@@ -1194,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 };
       }
     }
@@ -1206,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 };
       }
     }
@@ -1640,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)));
@@ -1650,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}`;
@@ -2138,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();
@@ -2217,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) {
@@ -2230,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:
@@ -2246,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)));
@@ -2269,13 +2462,20 @@ 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 "of":
       return abs({ k: "arr", element: a0 ?? unknown }, void 0, void 0, "path");
@@ -2313,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) {
@@ -3355,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");
     }
@@ -3640,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;
@@ -3665,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;
@@ -3676,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;
@@ -3688,8 +3890,8 @@ function recordAbsNode(node, value) {
 }
 var absAssignCollector = null;
 var assignFlowDepth = 0;
-function setAbsAssignCollector(collector) {
-  absAssignCollector = collector;
+function setAbsAssignCollector(collector2) {
+  absAssignCollector = collector2;
 }
 function evalInConditionalFlow(body) {
   assignFlowDepth++;
@@ -3718,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") {
@@ -3751,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;
@@ -3808,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;
@@ -3974,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);
@@ -4425,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
           );
@@ -4647,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) {
@@ -4838,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);
@@ -4971,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;
@@ -6725,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]) {
@@ -7150,22 +7445,6 @@ export {
   isStrPrim,
   isExactLit,
   litValue,
-  viewTemplateParts,
-  knownPrefixOfViews,
-  knownSuffixOfViews,
-  allFixedTextOfViews,
-  fixedLengthOfViews,
-  formatTemplateNameViews,
-  mergeAdjacentFixedViews,
-  templateMatchesValue,
-  decideStartsWith,
-  decideEndsWith,
-  decideIncludes,
-  absTemplateViews,
-  templatePartsOf,
-  createTemplateAbs,
-  isTemplateLike,
-  concatString,
   stripTypes,
   resetParseSourceCache,
   getParseSourceCacheSize,
@@ -7176,6 +7455,19 @@ export {
   relationFingerprint,
   relationFn,
   shapeOnlyFn,
+  setDerivationCollector,
+  hasDerivationSession,
+  beginDerivationSession,
+  endDerivationSession,
+  abortDerivationSession,
+  tagDerivationRoot,
+  getDerivation,
+  setDerivation,
+  derivationChain,
+  noteDerivationAdd,
+  noteDerivationJoin,
+  projectDerivationDsl,
+  termKey3 as termKey,
   objOf,
   isObj,
   getSlot,
@@ -7183,6 +7475,7 @@ export {
   joinObjects,
   joinValues,
   makeSum,
+  absShapeKey,
   fnOf,
   joinFunctions,
   joinAbs,
@@ -7205,6 +7498,22 @@ export {
   mapElementFallback,
   projectFlatMapResult,
   asAbs,
+  viewTemplateParts,
+  knownPrefixOfViews,
+  knownSuffixOfViews,
+  allFixedTextOfViews,
+  fixedLengthOfViews,
+  formatTemplateNameViews,
+  mergeAdjacentFixedViews,
+  templateMatchesValue,
+  decideStartsWith,
+  decideEndsWith,
+  decideIncludes,
+  absTemplateViews,
+  templatePartsOf,
+  createTemplateAbs,
+  isTemplateLike,
+  concatString,
   add,
   sub,
   mul,
@@ -7283,11 +7592,13 @@ export {
   setAbsNodeCollector,
   setAbsAssignCollector,
   evalSource,
+  callFunctionFull,
   callFunction,
   evalMethodBody,
   evalNode,
   applyAbsFn,
   analyzeFn,
+  analyzeFnFull,
   evalProgramAbs,
   collectAbsNodeTypes,
   findAbsAtPosition,