@nudojs/core 1.0.1 → 2.0.0

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

@@ -9,6 +9,8 @@ var runtime_exports = {};
 __export(runtime_exports, {
   $add: () => $add,
   $arr: () => $arr,
+  $arrMutContainer: () => $arrMutContainer,
+  $arrRest: () => $arrRest,
   $async: () => $async,
   $asyncReturn: () => $asyncReturn,
   $await: () => $await,
@@ -17,6 +19,7 @@ __export(runtime_exports, {
   $div: () => $div,
   $elems: () => $elems,
   $eq: () => $eq,
+  $eqLoose: () => $eqLoose,
   $fnVal: () => $fnVal,
   $for: () => $for,
   $forIter: () => $forIter,
@@ -28,38 +31,59 @@ __export(runtime_exports, {
   $gt: () => $gt,
   $idx: () => $idx,
   $idxSet: () => $idxSet,
+  $isForkExit: () => $isForkExit,
   $join: () => $join,
   $le: () => $le,
   $len: () => $len,
   $lit: () => $lit,
+  $loopReturn: () => $loopReturn,
   $lt: () => $lt,
   $mod: () => $mod,
   $mul: () => $mul,
   $ne: () => $ne,
+  $neLoose: () => $neLoose,
   $neg: () => $neg,
   $not: () => $not,
+  $nullishTest: () => $nullishTest,
   $obj: () => $obj,
+  $objRest: () => $objRest,
+  $pushLoopExit: () => $pushLoopExit,
   $regex: () => $regex,
+  $rethrowIfNudoReturn: () => $rethrowIfNudoReturn,
   $set: () => $set,
   $spread: () => $spread,
   $sub: () => $sub,
   $switch: () => $switch,
   $throw: () => $throw,
+  $tryCurrentMark: () => $tryCurrentMark,
+  $tryMark: () => $tryMark,
+  $tryPopMark: () => $tryPopMark,
+  $tryTakeSince: () => $tryTakeSince,
   $typeof: () => $typeof,
   $while: () => $while,
   $whileSeq: () => $whileSeq,
   $yield: () => $yield,
   DEFAULT_MAX_LOOP_ITERS: () => DEFAULT_MAX_LOOP_ITERS,
+  NudoReturn: () => NudoReturn,
   NudoThrow: () => NudoThrow,
   asAbsVal: () => asAbsVal,
+  callAtFunctionBoundary: () => callAtFunctionBoundary,
   currentExecPhi: () => currentExecPhi,
+  isArrMutator: () => isArrMutator,
   isDefinitelyFalse: () => isDefinitelyFalse,
   isDefinitelyTrue: () => isDefinitelyTrue,
+  isNudoReturn: () => isNudoReturn,
   isNudoThrow: () => isNudoThrow,
   litTruth: () => litTruth,
   namespaceNameOf: () => namespaceNameOf,
+  pushLoopExit: () => pushLoopExit,
+  pushThrowExit: () => pushThrowExit,
+  runWithLoopExits: () => runWithLoopExits,
+  takeLoopExits: () => takeLoopExits,
+  takeThrowExits: () => takeThrowExits,
   withExecPhi: () => withExecPhi
 });
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 
 // src/algebra/term.ts
 var lit = (value) => ({
@@ -170,11 +194,16 @@ var ptypeof = (t, type) => ({
 });
 function and(...preds) {
   const flat = [];
+  const pushUnique = (p) => {
+    if (flat.some((q) => predEquals(q, p))) return;
+    flat.push(p);
+  };
   for (const p of preds) {
     if (p.op === "true") continue;
     if (p.op === "false") return pFalse;
-    if (p.op === "and") flat.push(...p.args);
-    else flat.push(p);
+    if (p.op === "and") {
+      for (const q of p.args) pushUnique(q);
+    } else pushUnique(p);
   }
   if (flat.length === 0) return pTrue;
   if (flat.length === 1) return flat[0];
@@ -182,11 +211,16 @@ function and(...preds) {
 }
 function or(...preds) {
   const flat = [];
+  const pushUnique = (p) => {
+    if (flat.some((q) => predEquals(q, p))) return;
+    flat.push(p);
+  };
   for (const p of preds) {
     if (p.op === "false") continue;
     if (p.op === "true") return pTrue;
-    if (p.op === "or") flat.push(...p.args);
-    else flat.push(p);
+    if (p.op === "or") {
+      for (const q of p.args) pushUnique(q);
+    } else pushUnique(p);
   }
   if (flat.length === 0) return pFalse;
   if (flat.length === 1) return flat[0];
@@ -380,6 +414,25 @@ function extractBounds(phi2) {
   return { lo, hi };
 }
 function impliesViaBounds(pred, bounds) {
+  if (pred.op === "eq") {
+    const left2 = pred.a;
+    const right2 = pred.b;
+    if (right2.op !== "lit" || typeof right2.value !== "number") return void 0;
+    const n2 = right2.value;
+    if (left2.op === "var") {
+      return eqFromBounds(left2.id, n2, bounds);
+    }
+    if (left2.op === "app" && left2.fn === "+" && left2.args.length === 2) {
+      const [a, b] = left2.args;
+      if (a.op === "var" && b.op === "lit" && typeof b.value === "number") {
+        return eqFromBounds(a.id, n2 - b.value, bounds);
+      }
+      if (b.op === "var" && a.op === "lit" && typeof a.value === "number") {
+        return eqFromBounds(b.id, n2 - a.value, bounds);
+      }
+    }
+    return void 0;
+  }
   if (pred.op !== "gt" && pred.op !== "ge" && pred.op !== "lt" && pred.op !== "le") {
     return void 0;
   }
@@ -401,6 +454,20 @@ function impliesViaBounds(pred, bounds) {
   }
   return void 0;
 }
+function eqFromBounds(id, n, bounds) {
+  const lo = bounds.lo.get(id);
+  const hi = bounds.hi.get(id);
+  if (!lo || !hi) return void 0;
+  const loCovers = lo.strict ? lo.bound <= n : lo.bound <= n;
+  const hiCovers = hi.strict ? hi.bound >= n : hi.bound >= n;
+  if (lo.strict && lo.bound >= n) return false;
+  if (hi.strict && hi.bound <= n) return false;
+  if (!lo.strict && lo.bound > n) return false;
+  if (!hi.strict && hi.bound < n) return false;
+  if (!loCovers || !hiCovers) return void 0;
+  if (!lo.strict && !hi.strict && lo.bound === n && hi.bound === n) return true;
+  return void 0;
+}
 function cmpVar(id, op, n, bounds) {
   const lo = bounds.lo.get(id);
   const hi = bounds.hi.get(id);
@@ -709,173 +776,6 @@ 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";
-}
-function isStrPrim2(a) {
-  return a.shape.k === "prim" && a.shape.type === "string";
-}
-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;
-    return meta.templateParts;
-  }
-  return [a];
-}
-function rebuildAbsFixedView(text) {
-  return {
-    fixed: text,
-    render: text,
-    part: abs({ k: "prim", type: "string" }, lit(text), void 0, "exact")
-  };
-}
-function normalizeParts(parts) {
-  return mergeAdjacentFixedViews(absTemplateViews(parts), rebuildAbsFixedView).map((v2) => v2.part);
-}
-function formatTemplateName(parts) {
-  return formatTemplateNameViews(absTemplateViews(parts));
-}
-function createTemplateAbs(parts) {
-  const normalized = normalizeParts(parts);
-  if (normalized.length === 1) {
-    const only = normalized[0];
-    if (isStrLit(only)) return only;
-    if (isStrPrim2(only) && !isTemplateAbs(only)) return only;
-  }
-  const name = formatTemplateName(normalized);
-  const predObj = {
-    op: "true",
-    name,
-    meta: { templateParts: normalized }
-  };
-  return {
-    shape: { k: "prim", type: "string" },
-    term: void 0,
-    pred: predObj,
-    conf: "path"
-  };
-}
-function isTemplateLike(a) {
-  return isTemplateAbs(a);
-}
-function concatString(a, b) {
-  if (isStrLit(a) && isStrLit(b)) {
-    return abs(
-      { k: "prim", type: "string" },
-      lit(String(litValue(a)) + String(litValue(b))),
-      void 0,
-      "exact"
-    );
-  }
-  const aParts = coerceToStringParts(a);
-  const bParts = coerceToStringParts(b);
-  if (!aParts || !bParts) return abs({ k: "unknown" }, void 0, void 0, "partial");
-  return createTemplateAbs([...aParts, ...bParts]);
-}
-function coerceToStringParts(a) {
-  if (isTemplateAbs(a) || isStrPrim2(a)) return templatePartsOf(a);
-  if (isStrLit(a)) return [a];
-  const lv = litValue(a);
-  if (typeof lv === "number" || typeof lv === "boolean") {
-    return [abs({ k: "prim", type: "string" }, lit(String(lv)), void 0, "exact")];
-  }
-  if (a.shape.k === "prim" && a.shape.type === "number") {
-    return [a];
-  }
-  return void 0;
-}
-
 // src/algebra/derivation.ts
 var collector = null;
 var nextId = 1;
@@ -1084,114 +984,903 @@ function joinValues(a, 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")
-      );
+      const nanA = typeof va === "number" && Number.isNaN(va);
+      const nanB = typeof vb === "number" && Number.isNaN(vb);
+      if (nanA || nanB) {
+        return abs(a.shape, void 0, void 0, confJoin(confJoin(a.conf, b.conf), "path"));
+      }
+      return makeSum(a, b);
     }
     return abs(a.shape, void 0, void 0, confJoin(confJoin(a.conf, b.conf), "path"));
   }
-  return makeSum(a, b);
+  return makeSum(a, b);
+}
+function makeSum(a, b) {
+  const members = flattenSum([a, b]);
+  if (members.length === 1) return members[0];
+  if (members.length > 16) {
+    const first = members[0];
+    const samePrimLit = first.shape.k === "prim" && members.every(
+      (m) => m.shape.k === "prim" && m.shape.type === first.shape.type && litValue(m) !== void 0
+    );
+    if (samePrimLit) {
+      return abs(first.shape, void 0, void 0, "path");
+    }
+  }
+  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") {
+      if (a.term?.op === "lit" && a.term.value === void 0) return "unknown:undefined";
+      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 shapeBrief(a) {
+  const s = a.shape;
+  switch (s.k) {
+    case "never":
+      return "never";
+    case "unknown":
+    case "any":
+      return s.k;
+    case "prim":
+      return s.type;
+    case "arr":
+      return `${shapeBrief(s.element)}[]`;
+    case "obj":
+      return "{\u2026}";
+    case "tuple":
+      return `[${s.elements.length}]`;
+    case "fn":
+      return "fn";
+    case "brand":
+      return s.name;
+    case "eff":
+      return s.eff;
+    case "sum":
+      return s.members.map(shapeBrief).join("|");
+    default:
+      return "\xB7";
+  }
+}
+function annotateJoinPath(a, b, result) {
+  if (result === a || result === b) return result;
+  const sa = shapeBrief(a);
+  const sb = shapeBrief(b);
+  if (sa === sb) {
+    const extra = sameShapeJoinNote(a, b);
+    if (!extra) return result;
+    const note3 = `join(${sa}: ${extra})`;
+    if (result.pathNote === note3) return result;
+    return { ...result, pathNote: note3 };
+  }
+  const note2 = `join(${sa} | ${sb})`;
+  if (result.pathNote === note2) return result;
+  return { ...result, pathNote: note2 };
+}
+function sameShapeJoinNote(a, b) {
+  if (a.shape.k === "obj" && b.shape.k === "obj") {
+    const ak = Object.keys(a.shape.slots ?? {});
+    const bk = Object.keys(b.shape.slots ?? {});
+    const onlyA = ak.filter((k) => !bk.includes(k));
+    const onlyB = bk.filter((k) => !ak.includes(k));
+    if (onlyA.length === 0 && onlyB.length === 0) return void 0;
+    const parts = [];
+    if (onlyA.length > 0) parts.push(`+${onlyA.join(",")}`);
+    if (onlyB.length > 0) parts.push(`+${onlyB.join(",")}`);
+    return parts.join(" ");
+  }
+  if (a.shape.k === "tuple" && b.shape.k === "tuple") {
+    const la = a.shape.elements.length;
+    const lb = b.shape.elements.length;
+    if (la === lb) return void 0;
+    return `len ${la}|${lb}`;
+  }
+  if (a.shape.k === "brand" && b.shape.k === "brand") {
+    const an = a.shape.name;
+    const bn = b.shape.name;
+    if (an !== bn) return `brand ${an}|${bn}`;
+    const ai = a.shape.shape;
+    const bi = b.shape.shape;
+    return sameShapeJoinNote(ai, bi);
+  }
+  if (a.shape.k === "sum" && b.shape.k === "sum") {
+    const am = a.shape.members.map((m) => shapeBrief(m)).sort().join(",");
+    const bm = b.shape.members.map((m) => shapeBrief(m)).sort().join(",");
+    if (am === bm) return void 0;
+    return `sum ${am}|${bm}`;
+  }
+  return void 0;
+}
+function joinAbs(a, b) {
+  if (a.shape.k === "never") return b;
+  if (b.shape.k === "never") return a;
+  if (isObj(a) && isObj(b)) {
+    return annotateJoinPath(a, b, joinObjects(a, b));
+  }
+  if (a.shape.k === "fn" && b.shape.k === "fn") {
+    return annotateJoinPath(a, b, joinFunctions(a, b));
+  }
+  const result = joinValues(a, b);
+  noteDerivationJoin([a, b], result);
+  return annotateJoinPath(a, b, result);
+}
+
+// src/algebra/collections.ts
+var mapTables = /* @__PURE__ */ new WeakMap();
+var setTables = /* @__PURE__ */ new WeakMap();
+var armOverlays = [];
+function pushCollectionArm() {
+  armOverlays.push(/* @__PURE__ */ new WeakMap());
+}
+function popCollectionArm() {
+  return armOverlays.pop();
+}
+function cloneMapTable(t) {
+  return {
+    byLit: new Map(t.byLit),
+    shadowValues: [...t.shadowValues],
+    maybeAbsent: t.maybeAbsent ? new Set(t.maybeAbsent) : void 0
+  };
+}
+function cloneSetTable(t) {
+  return {
+    elements: [...t.elements],
+    maybeAbsent: t.maybeAbsent instanceof Set ? new Set(t.maybeAbsent) : t.maybeAbsent
+  };
+}
+function setAbsentKey(t, k) {
+  if (!t) return false;
+  if (t.maybeAbsent === true) return true;
+  return t.maybeAbsent instanceof Set && t.maybeAbsent.has(k);
+}
+function setAnyAbsent(t) {
+  if (!t) return false;
+  return t.maybeAbsent === true || t.maybeAbsent instanceof Set && t.maybeAbsent.size > 0;
+}
+function mergeCollectionArms(arms) {
+  endCollectionFork(arms);
+}
+var forkTouchedStack = [];
+function beginCollectionFork() {
+  forkTouchedStack.push(/* @__PURE__ */ new Set());
+}
+function noteCollectionWrite(id) {
+  const top = forkTouchedStack[forkTouchedStack.length - 1];
+  if (top) top.add(id);
+}
+function endCollectionFork(arms) {
+  const touched = forkTouchedStack.pop() ?? /* @__PURE__ */ new Set();
+  const live = arms.filter(Boolean);
+  if (live.length === 0) return;
+  const nested = armOverlays.length > 0;
+  const outerArm = nested ? armOverlays[armOverlays.length - 1] : void 0;
+  const commitMap = (id, merged) => {
+    if (outerArm) {
+      const e = outerArm.get(id) ?? {};
+      outerArm.set(id, { ...e, map: merged });
+    } else {
+      mapTables.set(id, merged);
+    }
+  };
+  const commitSet = (id, merged) => {
+    if (outerArm) {
+      const e = outerArm.get(id) ?? {};
+      outerArm.set(id, { ...e, set: merged });
+    } else {
+      setTables.set(id, merged);
+    }
+  };
+  for (const id of touched) {
+    const armTables = [];
+    const armSetTables = [];
+    let anyMap = false;
+    let anySet = false;
+    for (const arm of live) {
+      const e = arm.get(id);
+      if (e?.map) {
+        anyMap = true;
+        armTables.push(e.map);
+      } else if (anyMap || armTables.length > 0) {
+        armTables.push(void 0);
+      }
+      if (e?.set) {
+        anySet = true;
+        armSetTables.push(e.set);
+      } else if (anySet || armSetTables.length > 0) {
+        armSetTables.push(void 0);
+      }
+    }
+    if (anyMap || armTables.some(Boolean)) {
+      const base = (nested ? mapTableForReadBase(outerArm, id) : mapTables.get(id)) ?? emptyMapTable();
+      const perArm = live.map((arm) => {
+        const e = arm.get(id);
+        return e?.map ?? cloneMapTable(base);
+      });
+      const merged = { byLit: /* @__PURE__ */ new Map(), shadowValues: [], maybeAbsent: /* @__PURE__ */ new Set() };
+      const keyArms = /* @__PURE__ */ new Map();
+      const forcedAbsent = /* @__PURE__ */ new Set();
+      for (const t of perArm) {
+        for (const [k, v2] of t.byLit) {
+          const prev = merged.byLit.get(k);
+          merged.byLit.set(k, prev ? joinAbs(prev, v2) : v2);
+          keyArms.set(k, (keyArms.get(k) ?? 0) + 1);
+        }
+        for (const sv of t.shadowValues) merged.shadowValues.push(sv);
+        if (t.maybeAbsent) {
+          for (const k of t.maybeAbsent) forcedAbsent.add(k);
+        }
+      }
+      for (const [k, count] of keyArms) {
+        if (count < perArm.length) merged.maybeAbsent.add(k);
+      }
+      for (const k of forcedAbsent) merged.maybeAbsent.add(k);
+      if (merged.maybeAbsent.size === 0) delete merged.maybeAbsent;
+      commitMap(id, merged);
+    }
+    if (anySet || armSetTables.some(Boolean)) {
+      const base = (nested ? setTableForReadBase(outerArm, id) : setTables.get(id)) ?? emptySetTable();
+      const perArm = live.map((arm) => {
+        const e = arm.get(id);
+        return e?.set ?? cloneSetTable(base);
+      });
+      const seen = /* @__PURE__ */ new Set();
+      const mergedEls = [];
+      const litArmCount = /* @__PURE__ */ new Map();
+      const forcedAbsent = /* @__PURE__ */ new Set();
+      let wholeUncertain = false;
+      let hasNonLit = false;
+      for (const t of perArm) {
+        if (t.maybeAbsent === true) wholeUncertain = true;
+        if (t.maybeAbsent instanceof Set) {
+          for (const k of t.maybeAbsent) forcedAbsent.add(k);
+        }
+        const armLits = /* @__PURE__ */ new Set();
+        for (const el of t.elements) {
+          const lk = litKeyOf(el);
+          if (lk !== void 0) {
+            if (!seen.has(lk)) {
+              seen.add(lk);
+              mergedEls.push(el);
+            }
+            armLits.add(lk);
+          } else {
+            hasNonLit = true;
+            mergedEls.push(el);
+          }
+        }
+        for (const k of armLits) {
+          litArmCount.set(k, (litArmCount.get(k) ?? 0) + 1);
+        }
+      }
+      const maybeKeys = /* @__PURE__ */ new Set();
+      if (wholeUncertain || hasNonLit) {
+        wholeUncertain = true;
+      } else {
+        for (const [k, count] of litArmCount) {
+          if (count < perArm.length) maybeKeys.add(k);
+        }
+        for (const k of forcedAbsent) maybeKeys.add(k);
+      }
+      commitSet(id, {
+        elements: mergedEls,
+        maybeAbsent: wholeUncertain ? true : maybeKeys.size > 0 ? maybeKeys : void 0
+      });
+    }
+  }
+}
+function mapTableForReadBase(arm, id) {
+  return arm.get(id)?.map ?? mapTables.get(id);
+}
+function setTableForReadBase(arm, id) {
+  return arm.get(id)?.set ?? setTables.get(id);
+}
+function emptyMapTable() {
+  return { byLit: /* @__PURE__ */ new Map(), shadowValues: [] };
+}
+function emptySetTable() {
+  return { elements: [] };
+}
+function brandOf(name) {
+  return abs(
+    { k: "brand", name, shape: objOf({}) },
+    void 0,
+    void 0,
+    "path"
+  );
+}
+function litKeyOf(a) {
+  if (!a) return void 0;
+  if (a.term?.op === "lit") return a.term.value;
+  const v2 = litValue(a);
+  if (v2 === void 0 && a.term === void 0) return void 0;
+  return v2;
+}
+function isMapAbs(a) {
+  return !!a && a.shape.k === "brand" && a.shape.name === "Map";
+}
+function isSetAbs(a) {
+  return !!a && a.shape.k === "brand" && a.shape.name === "Set";
+}
+function elementsFrom(iterable) {
+  if (!iterable) return [];
+  if (iterable.shape.k === "tuple") return [...iterable.shape.elements];
+  if (iterable.shape.k === "arr") {
+    return [iterable.shape.element];
+  }
+  if (iterable.shape.k === "sum") {
+    return iterable.shape.members.flatMap(elementsFrom);
+  }
+  return [];
+}
+function makeMapAbs(iterable) {
+  const m = brandOf("Map");
+  const table = emptyMapTable();
+  for (const el of elementsFrom(iterable)) {
+    if (el.shape.k === "tuple" && el.shape.elements.length >= 2) {
+      const k = litKeyOf(el.shape.elements[0]);
+      const v2 = el.shape.elements[1];
+      if (k !== void 0) table.byLit.set(k, v2);
+      else table.shadowValues.push(v2);
+    }
+  }
+  mapTables.set(m, table);
+  return m;
+}
+function makeSetAbs(iterable) {
+  const s = brandOf("Set");
+  const table = emptySetTable();
+  const seen = /* @__PURE__ */ new Set();
+  for (const el of elementsFrom(iterable)) {
+    const lk = litKeyOf(el);
+    if (lk !== void 0) {
+      if (seen.has(lk)) continue;
+      seen.add(lk);
+    }
+    table.elements.push(el);
+  }
+  setTables.set(s, table);
+  return s;
+}
+function mapTableOf(a) {
+  const existing = mapTables.get(a);
+  if (existing) return existing;
+  const t = emptyMapTable();
+  mapTables.set(a, t);
+  return t;
+}
+function setTableOf(a) {
+  const existing = setTables.get(a);
+  if (existing) return existing;
+  const t = emptySetTable();
+  setTables.set(a, t);
+  return t;
+}
+function mapTableForWrite(a) {
+  noteCollectionWrite(a);
+  if (armOverlays.length > 0) {
+    let base;
+    for (let i = 0; i < armOverlays.length; i++) {
+      const e = armOverlays[i].get(a);
+      if (e?.map) base = e.map;
+    }
+    if (!base) base = mapTables.get(a);
+    const top = armOverlays[armOverlays.length - 1];
+    let entry = top.get(a);
+    if (!entry?.map) {
+      const cloned = cloneMapTable(base ?? emptyMapTable());
+      entry = { ...entry ?? {}, map: cloned };
+      top.set(a, entry);
+      return cloned;
+    }
+    return entry.map;
+  }
+  return mapTableOf(a);
+}
+function mapTableForRead(a) {
+  for (let i = armOverlays.length - 1; i >= 0; i--) {
+    const entry = armOverlays[i].get(a);
+    if (entry?.map) return entry.map;
+  }
+  return mapTables.get(a);
+}
+function setTableForWrite(a) {
+  noteCollectionWrite(a);
+  if (armOverlays.length > 0) {
+    let base;
+    for (let i = 0; i < armOverlays.length; i++) {
+      const e = armOverlays[i].get(a);
+      if (e?.set) base = e.set;
+    }
+    if (!base) base = setTables.get(a);
+    const top = armOverlays[armOverlays.length - 1];
+    let entry = top.get(a);
+    if (!entry?.set) {
+      const cloned = cloneSetTable(base ?? emptySetTable());
+      entry = { ...entry ?? {}, set: cloned };
+      top.set(a, entry);
+      return cloned;
+    }
+    return entry.set;
+  }
+  return setTableOf(a);
+}
+function setTableForRead(a) {
+  for (let i = armOverlays.length - 1; i >= 0; i--) {
+    const entry = armOverlays[i].get(a);
+    if (entry?.set) return entry.set;
+  }
+  return setTables.get(a);
+}
+function mapSetEntry(mapAbs, key, value) {
+  const t = mapTableForWrite(mapAbs);
+  const k = litKeyOf(key);
+  if (k !== void 0) t.byLit.set(k, value);
+  else if (value) t.shadowValues.push(value);
+  return mapAbs;
+}
+function mapDeleteEntry(mapAbs, key) {
+  const t = mapTableForWrite(mapAbs);
+  const k = litKeyOf(key);
+  if (k !== void 0) {
+    t.byLit.delete(k);
+    t.maybeAbsent?.delete(k);
+  } else if (t.shadowValues.length === 0 && t.byLit.size > 0) {
+    t.maybeAbsent = new Set(t.byLit.keys());
+  }
+  return abs(
+    { k: "prim", type: "boolean" },
+    void 0,
+    void 0,
+    "path"
+  );
+}
+function mapClearEntries(mapAbs) {
+  const t = mapTableForWrite(mapAbs);
+  t.byLit.clear();
+  t.shadowValues.length = 0;
+  delete t.maybeAbsent;
+  return undefAbs();
+}
+function undefAbs() {
+  return abs({ k: "unknown" }, { op: "lit", value: void 0 }, void 0, "exact");
+}
+function joinAll(els) {
+  if (els.length === 0) return void 0;
+  return els.reduce((a, b) => joinAbs(a, b));
+}
+function mapGetEntry(mapAbs, key) {
+  const t = mapTableForRead(mapAbs);
+  if (!t) return unknown;
+  const k = litKeyOf(key);
+  if (k !== void 0) {
+    const v2 = t.byLit.get(k);
+    const absent = t.maybeAbsent?.has(k) === true;
+    if (v2 !== void 0 && !absent && t.shadowValues.length === 0) return v2;
+    if (v2 !== void 0) {
+      return joinAll([v2, ...t.shadowValues, undefAbs()]) ?? undefAbs();
+    }
+    if (t.shadowValues.length === 0) return undefAbs();
+  }
+  const known = [...t.byLit.values(), ...t.shadowValues];
+  const joined = joinAll(known);
+  if (k !== void 0 && t.shadowValues.length === 0) {
+    return undefAbs();
+  }
+  if (joined === void 0) {
+    return k !== void 0 ? undefAbs() : unknown;
+  }
+  return joinAbs(joined, undefAbs());
+}
+function mapHasEntry(mapAbs, key) {
+  const t = mapTableForRead(mapAbs);
+  if (!t) return unknown;
+  const k = litKeyOf(key);
+  if (k === void 0) {
+    return t.byLit.size > 0 || t.shadowValues.length > 0 ? abs({ k: "prim", type: "boolean" }, void 0, void 0, "partial") : unknown;
+  }
+  const hit = t.byLit.has(k);
+  const maybeAbsent = t.maybeAbsent?.has(k) === true;
+  if (t.shadowValues.length > 0 || maybeAbsent) {
+    return abs({ k: "prim", type: "boolean" }, void 0, void 0, "partial");
+  }
+  return abs(
+    { k: "prim", type: "boolean" },
+    { op: "lit", value: hit },
+    void 0,
+    "exact"
+  );
+}
+function mapSizeAbs(mapAbs) {
+  const t = mapTableForRead(mapAbs);
+  if (!t || t.shadowValues.length > 0 || t.maybeAbsent && t.maybeAbsent.size > 0) {
+    return abs({ k: "prim", type: "number" }, void 0, void 0, "path");
+  }
+  return abs(
+    { k: "prim", type: "number" },
+    { op: "lit", value: t.byLit.size },
+    void 0,
+    "exact"
+  );
+}
+function mapValuesAbs(mapAbs) {
+  const t = mapTableForRead(mapAbs);
+  if (!t) return [];
+  return [...t.byLit.values(), ...t.shadowValues];
+}
+function keyAbsFromLitKey(k) {
+  if (k === null) {
+    return abs({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
+  }
+  if (k === void 0) {
+    return abs({ k: "unknown" }, { op: "lit", value: void 0 }, void 0, "exact");
+  }
+  if (typeof k === "string") return abs({ k: "prim", type: "string" }, { op: "lit", value: k }, void 0, "exact");
+  if (typeof k === "number") return abs({ k: "prim", type: "number" }, { op: "lit", value: k }, void 0, "exact");
+  return abs({ k: "prim", type: "boolean" }, { op: "lit", value: k }, void 0, "exact");
+}
+function mapEntriesAbs(mapAbs) {
+  const t = mapTableForRead(mapAbs);
+  if (!t) return [];
+  const entries = [];
+  for (const [k, v2] of t.byLit) {
+    entries.push(
+      abs(
+        { k: "tuple", elements: [keyAbsFromLitKey(k), v2] },
+        void 0,
+        void 0,
+        confJoin(v2.conf, "exact")
+      )
+    );
+  }
+  const unkKey = abs({ k: "unknown" }, void 0, void 0, "partial");
+  for (const v2 of t.shadowValues) {
+    entries.push(
+      abs(
+        { k: "tuple", elements: [unkKey, v2] },
+        void 0,
+        void 0,
+        "partial"
+      )
+    );
+  }
+  return entries;
+}
+function setAddEntry(setAbs, value) {
+  const t = setTableForWrite(setAbs);
+  const lk = litKeyOf(value);
+  if (lk !== void 0 && t.elements.some((el) => litKeyOf(el) === lk)) {
+    return setAbs;
+  }
+  t.elements.push(value);
+  return setAbs;
+}
+function setDeleteEntry(setAbs, value) {
+  const t = setTableForWrite(setAbs);
+  const lk = litKeyOf(value);
+  if (lk !== void 0) {
+    t.elements = t.elements.filter((el) => litKeyOf(el) !== lk);
+    const hasUnknown = t.elements.some((el) => litKeyOf(el) === void 0);
+    if (hasUnknown) t.maybeAbsent = true;
+    else delete t.maybeAbsent;
+  } else {
+    t.maybeAbsent = true;
+  }
+  return abs({ k: "prim", type: "boolean" }, void 0, void 0, "path");
+}
+function setClearEntries(setAbs) {
+  const t = setTableForWrite(setAbs);
+  t.elements = [];
+  delete t.maybeAbsent;
+  return undefAbs();
+}
+function setHasEntry(setAbs, value) {
+  const t = setTableForRead(setAbs);
+  if (!t) return unknown;
+  const k = litKeyOf(value);
+  if (k !== void 0) {
+    const hit = t.elements.some((el) => litKeyOf(el) === k);
+    if (setAbsentKey(t, k)) {
+      return abs({ k: "prim", type: "boolean" }, void 0, void 0, "partial");
+    }
+    return abs(
+      { k: "prim", type: "boolean" },
+      { op: "lit", value: hit },
+      void 0,
+      "exact"
+    );
+  }
+  return abs({ k: "prim", type: "boolean" }, void 0, void 0, "partial");
+}
+function setSizeAbs(setAbs) {
+  const t = setTableForRead(setAbs);
+  if (!t || setAnyAbsent(t)) {
+    return abs({ k: "prim", type: "number" }, void 0, void 0, "path");
+  }
+  return abs(
+    { k: "prim", type: "number" },
+    { op: "lit", value: t.elements.length },
+    void 0,
+    "exact"
+  );
+}
+function setElementsAbs(setAbs) {
+  const t = setTableForRead(setAbs);
+  return t ? [...t.elements] : [];
+}
+function collectionExactLen(c) {
+  if (isSetAbs(c)) {
+    const t = setTableForRead(c);
+    if (!t) return void 0;
+    if (t.maybeAbsent === true || t.maybeAbsent instanceof Set && t.maybeAbsent.size > 0) {
+      return void 0;
+    }
+    return t.elements.length;
+  }
+  if (isMapAbs(c)) {
+    const t = mapTableForRead(c);
+    if (!t) return void 0;
+    if (t.shadowValues.length > 0 || t.maybeAbsent && t.maybeAbsent.size > 0) {
+      return void 0;
+    }
+    return t.byLit.size;
+  }
+  return void 0;
+}
+function collectionElementJoin(c) {
+  const els = isSetAbs(c) ? setElementsAbs(c) : isMapAbs(c) ? mapEntriesAbs(c) : [];
+  if (els.length === 0) return unknown;
+  return els.reduce((a, b) => joinAbs(a, b));
+}
+function clearCollectionTables() {
+}
+
+// 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";
+}
+function isStrPrim2(a) {
+  return a.shape.k === "prim" && a.shape.type === "string";
+}
+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;
+    return meta.templateParts;
+  }
+  return [a];
 }
-function makeSum(a, b) {
-  const members = flattenSum([a, b]);
-  if (members.length === 1) return members[0];
+function rebuildAbsFixedView(text) {
   return {
-    shape: { k: "sum", members },
-    conf: confJoin(a.conf, b.conf)
+    fixed: text,
+    render: text,
+    part: abs({ k: "prim", type: "string" }, lit(text), void 0, "exact")
   };
 }
-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 normalizeParts(parts) {
+  return mergeAdjacentFixedViews(absTemplateViews(parts), rebuildAbsFixedView).map((v2) => v2.part);
 }
-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 formatTemplateName(parts) {
+  return formatTemplateNameViews(absTemplateViews(parts));
+}
+function createTemplateAbs(parts) {
+  const normalized = normalizeParts(parts);
+  if (normalized.length === 1) {
+    const only = normalized[0];
+    if (isStrLit(only)) return only;
+    if (isStrPrim2(only) && !isTemplateAbs(only)) return only;
   }
+  const name = formatTemplateName(normalized);
+  const predObj = {
+    op: "true",
+    name,
+    meta: { templateParts: normalized }
+  };
+  return {
+    shape: { k: "prim", type: "string" },
+    term: void 0,
+    pred: predObj,
+    conf: "path"
+  };
 }
-function fnOf(params, name) {
-  const shape = { k: "fn", params };
-  if (name) shape.name = name;
-  return { shape, conf: "exact" };
+function isTemplateLike(a) {
+  return isTemplateAbs(a);
 }
-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;
-    }
+function concatString(a, b) {
+  if (isStrLit(a) && isStrLit(b)) {
+    return abs(
+      { k: "prim", type: "string" },
+      lit(String(litValue(a)) + String(litValue(b))),
+      void 0,
+      "exact"
+    );
   }
-  return makeSum(a, b);
+  const aParts = coerceToStringParts(a);
+  const bParts = coerceToStringParts(b);
+  if (!aParts || !bParts) return abs({ k: "unknown" }, void 0, void 0, "partial");
+  return createTemplateAbs([...aParts, ...bParts]);
 }
-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;
+function coerceToStringParts(a) {
+  if (isTemplateAbs(a) || isStrPrim2(a)) return templatePartsOf(a);
+  if (isStrLit(a)) return [a];
+  const lv = litValue(a);
+  if (typeof lv === "number" || typeof lv === "boolean") {
+    return [abs({ k: "prim", type: "string" }, lit(String(lv)), void 0, "exact")];
+  }
+  if (a.shape.k === "prim" && a.shape.type === "number") {
+    return [a];
+  }
+  return void 0;
 }
 
 // src/algebra/arithmetic.ts
@@ -1877,9 +2566,9 @@ function definitelyNotNullishShape(s) {
   }
 }
 function isNullishLitAbs(a) {
-  const v2 = litValue(a);
-  if (v2 === null || v2 === void 0) return true;
-  return false;
+  const t = a.term;
+  if (!t || t.op !== "lit") return false;
+  return t.value === null || t.value === void 0;
 }
 function strictEqAbs(a, b) {
   const va = litValue(a);
@@ -1894,6 +2583,26 @@ function strictEqAbs(a, b) {
   }
   return void 0;
 }
+function abstractEq(x, y) {
+  if (x === y) return true;
+  if (x === null && y === void 0) return true;
+  if (x === void 0 && y === null) return true;
+  if (typeof x === "number" && Number.isNaN(x)) return false;
+  if (typeof y === "number" && Number.isNaN(y)) return false;
+  if (typeof x === "boolean") return abstractEq(x ? 1 : 0, y);
+  if (typeof y === "boolean") return abstractEq(x, y ? 1 : 0);
+  if (typeof x === "number" && typeof y === "string") return x === Number(y);
+  if (typeof x === "string" && typeof y === "number") return Number(x) === y;
+  return false;
+}
+function looseEqAbs(a, b) {
+  const ta = a.term;
+  const tb = b.term;
+  if (ta?.op === "lit" && tb?.op === "lit") {
+    return abstractEq(ta.value, tb.value);
+  }
+  return strictEqAbs(a, b);
+}
 
 // src/algebra/containers.ts
 var TUPLE_LITERAL_CAP = 8;
@@ -2115,6 +2824,13 @@ function leqWithPred(src, tgt, phi2, env, depth) {
   const tv = litValue(tgt);
   if (sv !== void 0 && tv !== void 0) {
     if (sv === tv) return ok();
+    if (tgt.shape.k === "prim") {
+      return fail(`lit ${String(sv)} \u22AD lit ${String(tv)}`);
+    }
+  } else if (tv !== void 0 && sv === void 0) {
+    if (tgt.shape.k === "prim") {
+      return fail(`non-lit prim \u22AD lit ${String(tv)}`);
+    }
   }
   const shapeR = leqShape(src, tgt, phi2, env, depth);
   if (!shapeR.ok) return shapeR;
@@ -2215,6 +2931,11 @@ function leqShape(src, tgt, phi2, env, depth) {
       if (srcSlot.optional && !slot.optional) {
         return fail(`slot ${key}: optional \u22AD required`);
       }
+      const ssv = litValue(srcSlot.value);
+      const stv = litValue(slot.value);
+      if (ssv !== void 0 && stv !== void 0 && primOf(srcSlot.value) !== void 0 && primOf(srcSlot.value) === primOf(slot.value)) {
+        continue;
+      }
       const r = leqWithPred(srcSlot.value, slot.value, phi2, env, depth + 1);
       if (!r.ok) return fail(`slot ${key}: ${r.reason}`);
     }
@@ -2481,6 +3202,10 @@ function evalArrayStatic(name, args) {
       return abs({ k: "arr", element: a0 ?? unknown }, void 0, void 0, "path");
     case "from": {
       if (!a0) return unknown;
+      if (isSetAbs(a0) || isMapAbs(a0)) {
+        const el = collectionElementJoin(a0);
+        return abs({ k: "arr", element: el }, void 0, void 0, "path");
+      }
       const k = a0.shape.k;
       if (k === "arr") return a0;
       if (k === "tuple") {
@@ -2599,6 +3324,35 @@ function evalNamespaceCall(ns, method, args) {
       return void 0;
   }
 }
+var ERROR_CTOR_NAMES = /* @__PURE__ */ new Set([
+  "Error",
+  "TypeError",
+  "RangeError",
+  "SyntaxError",
+  "ReferenceError",
+  "URIError",
+  "EvalError",
+  "AggregateError"
+]);
+function isErrorCtorName(name) {
+  return !!name && ERROR_CTOR_NAMES.has(name);
+}
+function errorBrandAbs(name, messageArg) {
+  const message = messageArg ?? strPrim();
+  return abs(
+    {
+      k: "brand",
+      name,
+      shape: objOf({
+        name: { value: strLit(name) },
+        message: { value: message }
+      })
+    },
+    void 0,
+    void 0,
+    "path"
+  );
+}
 function evalBuiltinNew(className, args) {
   switch (className) {
     case "Date":
@@ -2608,20 +3362,13 @@ function evalBuiltinNew(className, args) {
     case "Promise":
       return evalPromiseCtor(args);
     case "Map":
-      return abs(
-        { k: "brand", name: "Map", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-        void 0,
-        void 0,
-        "path"
-      );
+      return makeMapAbs(args[0]);
     case "Set":
-      return abs(
-        { k: "brand", name: "Set", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-        void 0,
-        void 0,
-        "path"
-      );
+      return makeSetAbs(args[0]);
     default:
+      if (isErrorCtorName(className)) {
+        return errorBrandAbs(className, args[0]);
+      }
       return void 0;
   }
 }
@@ -2631,13 +3378,17 @@ function evalBuiltinInstanceMethod(brandName, method, recv, args) {
   if (brandName === "Map") {
     switch (method) {
       case "get":
-        return unknown;
+        return mapGetEntry(recv, args[0]);
       case "has":
-        return boolPrim();
+        return mapHasEntry(recv, args[0]);
       case "set":
-        return recv;
+        return mapSetEntry(recv, args[0], args[1] ?? unknown);
+      case "delete":
+        return mapDeleteEntry(recv, args[0]);
+      case "clear":
+        return mapClearEntries(recv);
       case "size":
-        return numPrim("path");
+        return mapSizeAbs(recv);
       default:
         return void 0;
     }
@@ -2645,11 +3396,15 @@ function evalBuiltinInstanceMethod(brandName, method, recv, args) {
   if (brandName === "Set") {
     switch (method) {
       case "has":
-        return boolPrim();
+        return setHasEntry(recv, args[0]);
       case "add":
-        return recv;
+        return setAddEntry(recv, args[0] ?? unknown);
+      case "delete":
+        return setDeleteEntry(recv, args[0]);
+      case "clear":
+        return setClearEntries(recv);
       case "size":
-        return numPrim("path");
+        return setSizeAbs(recv);
       default:
         return void 0;
     }
@@ -2663,11 +3418,15 @@ __export(calls_exports, {
   $callNamed: () => $callNamed,
   getAbsOrigin: () => getAbsOrigin,
   getBCallCollector: () => getBCallCollector,
+  isEvalMissingSlotEnabled: () => isEvalMissingSlotEnabled,
   noteMemberDispatchMiss: () => noteMemberDispatchMiss,
+  noteObjSlotMissing: () => noteObjSlotMissing,
   notePrimMemberMissing: () => notePrimMemberMissing,
   noteUnknownMemberMissing: () => noteUnknownMemberMissing,
   recordMemberDiag: () => recordMemberDiag,
+  runWithEvalMissingSlot: () => runWithEvalMissingSlot,
   setBCallCollector: () => setBCallCollector,
+  setEvalMissingSlotEnabled: () => setEvalMissingSlotEnabled,
   setMemberDiagCollector: () => setMemberDiagCollector,
   tagAbsOrigin: () => tagAbsOrigin
 });
@@ -3394,6 +4153,19 @@ function setApplyCallbackHost(fn) {
   applyCallbackHost = fn;
 }
 function applyCallbackAbs(cb, args, env, phi2, budget) {
+  const sumIdx = args.findIndex(
+    (a) => a && typeof a === "object" && "shape" in a && a.shape.k === "sum"
+  );
+  if (sumIdx >= 0) {
+    const members = args[sumIdx].shape.members;
+    let acc;
+    for (const m of members) {
+      const nextArgs = args.map((a, i) => i === sumIdx ? m : a);
+      const r = applyCallbackAbs(cb, nextArgs, env, phi2, budget);
+      acc = acc === void 0 ? r : joinAbs(acc, r);
+    }
+    return acc ?? unknown;
+  }
   if (!applyCallbackHost) {
     if (cb && typeof cb === "object" && "shape" in cb) {
       const a = cb;
@@ -3405,7 +4177,7 @@ function applyCallbackAbs(cb, args, env, phi2, budget) {
   }
   return applyCallbackHost(cb, args, env, phi2, budget);
 }
-function undefAbs() {
+function undefAbs2() {
   return abs(
     { k: "unknown" },
     { op: "lit", value: void 0 },
@@ -3585,6 +4357,7 @@ function getAbsProperty(recv, name) {
 }
 
 // src/algebra/exec/member-diag.ts
+import { AsyncLocalStorage } from "async_hooks";
 var memberDiagCollector = null;
 var callLocStack = [];
 var absOrigins = /* @__PURE__ */ new WeakMap();
@@ -3684,7 +4457,41 @@ function noteUnknownMemberMissing(recv, name, kind, loc) {
 }
 function noteMemberDispatchMiss(recv, name, kind, loc) {
   if (notePrimMemberMissing(recv, name, kind, loc)) return;
-  noteUnknownMemberMissing(recv, name, kind, loc);
+  if (noteUnknownMemberMissing(recv, name, kind, loc)) return;
+  noteObjSlotMissing(recv, name, loc);
+}
+var evalMissingSlotAls = new AsyncLocalStorage();
+var evalMissingSlotFallback = false;
+function setEvalMissingSlotEnabled(enabled) {
+  evalMissingSlotFallback = enabled;
+  evalMissingSlotAls.enterWith(enabled);
+}
+function isEvalMissingSlotEnabled() {
+  return evalMissingSlotAls.getStore() ?? evalMissingSlotFallback;
+}
+function runWithEvalMissingSlot(enabled, body) {
+  return evalMissingSlotAls.run(enabled, body);
+}
+function noteObjSlotMissing(recv, name, loc) {
+  if (!isEvalMissingSlotEnabled()) return false;
+  const shape = recv?.shape;
+  if (!shape || shape.k !== "obj") return false;
+  const obj2 = shape;
+  if (obj2.open) return false;
+  if (obj2.slots && name in obj2.slots) return false;
+  const conf = recv?.conf;
+  if (conf === "opaque" || conf === "widened") return false;
+  const origin = getAbsOrigin(recv);
+  recordMemberDiag({
+    kind: "property",
+    name,
+    receiver: "object",
+    code: "nudo:missing-slot",
+    line: loc?.[0],
+    column: loc?.[1],
+    ...origin ? { origin } : {}
+  });
+  return true;
 }
 
 // src/algebra/exec/class-registry.ts
@@ -3809,6 +4616,28 @@ function withVar(env, name, value) {
   vars.set(name, value);
   return { vars, fns: env.fns, classes: env.classes, hofCollect: env.hofCollect };
 }
+function joinEnvs(a, b, base) {
+  const vars = new Map(base.vars);
+  const keys = /* @__PURE__ */ new Set([...a.vars.keys(), ...b.vars.keys()]);
+  for (const k of keys) {
+    const va = a.vars.get(k);
+    const vb = b.vars.get(k);
+    const baseV = base.vars.get(k);
+    if (va !== void 0 && vb !== void 0) {
+      vars.set(k, va === vb ? va : joinAbs(va, vb));
+    } else if (va !== void 0) {
+      vars.set(k, baseV !== void 0 ? joinAbs(baseV, va) : va);
+    } else if (vb !== void 0) {
+      vars.set(k, baseV !== void 0 ? joinAbs(baseV, vb) : vb);
+    }
+  }
+  return {
+    vars,
+    fns: a.fns ?? b.fns,
+    classes: a.classes ?? b.classes,
+    hofCollect: a.hofCollect ?? b.hofCollect
+  };
+}
 var MAX_CALL_DEPTH = 64;
 var MAX_TOTAL_CALLS = 2e5;
 var _absCallDepth = 0;
@@ -4169,8 +4998,66 @@ function evalNodeInner(node, env, phi2, budget) {
     }
     case "AssignmentExpression": {
       const ae = node;
-      if (ae.operator !== "=") return ok2(unknown, phi2, env);
-      const rhs = evalNode(ae.right, env, phi2, budget).value;
+      const op = ae.operator;
+      const applyBin = (binOp, lhs, rhsAbs) => {
+        switch (binOp) {
+          case "+":
+            return leakIfNeeded(add(lhs, rhsAbs, phi2), budget, "add");
+          case "-":
+            return leakIfNeeded(sub(lhs, rhsAbs, phi2), budget, "sub");
+          case "*":
+            return leakIfNeeded(mul(lhs, rhsAbs, phi2), budget, "mul");
+          case "/":
+            return leakIfNeeded(div(lhs, rhsAbs, phi2), budget, "div");
+          case "%":
+            return leakIfNeeded(mod(lhs, rhsAbs, phi2), budget, "mod");
+          default:
+            return unknown;
+        }
+      };
+      let rhs;
+      if (op === "=") {
+        rhs = evalNode(ae.right, env, phi2, budget).value;
+      } else if (op === "||=" || op === "&&=" || op === "??=") {
+        const lhs = evalNode(ae.left, env, phi2, budget).value;
+        const lv = litValue(lhs);
+        const nullishLit = isNullishLitAbs(lhs);
+        const definitelyNotNullish = definitelyNotNullishShape(lhs.shape) && !nullishLit;
+        const falsy = lv === false || nullishLit || lv === null || lv === void 0 && lhs.term?.op === "lit" && lhs.term.value === void 0;
+        const truthy = lv !== void 0 && !falsy && !nullishLit;
+        let assignRhs = null;
+        if (op === "||=") {
+          if (truthy) return ok2(lhs, phi2, env);
+          if (falsy || nullishLit) {
+            assignRhs = evalNode(ae.right, env, phi2, budget).value;
+          }
+        } else if (op === "&&=") {
+          if (falsy) return ok2(lhs, phi2, env);
+          if (truthy) {
+            assignRhs = evalNode(ae.right, env, phi2, budget).value;
+          }
+        } else {
+          if (definitelyNotNullish || lv !== void 0 && lv !== null && !nullishLit) {
+            return ok2(lhs, phi2, env);
+          }
+          if (nullishLit || lv === null || lv === void 0 && lhs.term?.op === "lit") {
+            assignRhs = evalNode(ae.right, env, phi2, budget).value;
+          }
+        }
+        if (assignRhs === null) {
+          const r = evalNode(ae.right, env, phi2, budget).value;
+          rhs = joinAbs(lhs, r);
+        } else {
+          rhs = assignRhs;
+        }
+      } else if (op.endsWith("=")) {
+        const binOp = op.slice(0, -1);
+        const lhs = evalNode(ae.left, env, phi2, budget).value;
+        const rhsVal = evalNode(ae.right, env, phi2, budget).value;
+        rhs = applyBin(binOp, lhs, rhsVal);
+      } else {
+        return ok2(unknown, phi2, env);
+      }
       if (ae.left.type === "MemberExpression" && ae.left.object.type === "ThisExpression") {
         const prop = ae.left.property;
         const key = !ae.left.computed && prop.type === "Identifier" ? prop.name : prop.type === "StringLiteral" ? prop.value : void 0;
@@ -4204,6 +5091,25 @@ function evalNodeInner(node, env, phi2, budget) {
         recordAbsAssign(name, prev, rhs, loc);
         return { value: rhs, phi: phi2, env: withVar(env, name, rhs) };
       }
+      if (ae.left.type === "MemberExpression") {
+        const m = ae.left;
+        if (m.object.type === "Identifier") {
+          const root = m.object.name;
+          const prev = env.vars.get(root);
+          const key = !m.computed ? m.property.type === "Identifier" ? m.property.name : m.property.type === "StringLiteral" ? m.property.value : void 0 : void 0;
+          if (prev && key && prev.shape.k === "obj") {
+            const slots = { ...prev.shape.slots };
+            slots[key] = { value: rhs };
+            const updated = abs(
+              { k: "obj", slots },
+              void 0,
+              void 0,
+              prev.conf === "exact" ? "path" : prev.conf
+            );
+            return { value: rhs, phi: phi2, env: withVar(env, root, updated) };
+          }
+        }
+      }
       return ok2(rhs, phi2, env);
     }
     case "AwaitExpression": {
@@ -4233,7 +5139,7 @@ function evalNodeInner(node, 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 };
+      return { value: joinAbs(a.value, b.value), phi: phi2, env: joinEnvs(a.env, b.env, env) };
     }
     case "ForStatement":
       return evalFor(node, env, phi2, budget);
@@ -4264,6 +5170,8 @@ function evalNodeInner(node, env, phi2, budget) {
     }
     case "IfStatement":
       return evalIf(node, env, phi2, budget);
+    case "SwitchStatement":
+      return evalSwitch(node, env, phi2, budget);
     case "ExpressionStatement":
       return evalNode(node.expression, env, phi2, budget);
     case "VariableDeclaration":
@@ -4285,8 +5193,10 @@ function evalNodeInner(node, env, phi2, budget) {
       const le3 = node;
       const l = evalNode(le3.left, env, phi2, budget);
       const lv = litValue(l.value);
-      const falsy = lv === false || lv === null || lv === void 0;
-      const truthy = lv !== void 0 && !falsy;
+      const nullishLit = isNullishLitAbs(l.value);
+      const definitelyNotNullish = definitelyNotNullishShape(l.value.shape) && !nullishLit;
+      const falsy = lv === false || nullishLit || lv === void 0 && l.value.term?.op === "lit" && l.value.term.value === void 0 || lv === null;
+      const truthy = lv !== void 0 && !falsy && !nullishLit;
       if (le3.operator === "&&") {
         if (falsy) return ok2(l.value, phi2, env);
         if (truthy) return evalNode(le3.right, env, phi2, budget);
@@ -4299,6 +5209,14 @@ function evalNodeInner(node, env, phi2, budget) {
         const r = evalNode(le3.right, env, phi2, budget);
         return ok2(joinAbs(l.value, r.value), phi2, env);
       }
+      if (le3.operator === "??") {
+        if (nullishLit || lv === null) return evalNode(le3.right, env, phi2, budget);
+        if (definitelyNotNullish || lv !== void 0 && lv !== null) {
+          return ok2(l.value, phi2, env);
+        }
+        const r = evalNode(le3.right, env, phi2, budget);
+        return ok2(joinAbs(l.value, r.value), phi2, env);
+      }
       return ok2(unknown, phi2, env);
     }
     case "TemplateLiteral": {
@@ -4388,12 +5306,39 @@ function evalNodeInner(node, env, phi2, budget) {
           acc = spread(acc, sp);
           continue;
         }
-        const keyNode = p.key;
+        if (p.type === "ObjectMethod") {
+          const om = p;
+          const keyNode2 = om.key;
+          let key2;
+          if (keyNode2 && keyNode2.type === "Identifier") key2 = keyNode2.name;
+          if (keyNode2 && keyNode2.type === "StringLiteral") key2 = keyNode2.value;
+          if (!key2 || !om.body) continue;
+          const paramNames = (om.params ?? []).map(
+            (pp, i) => pp.type === "Identifier" ? pp.name : `_a${i}`
+          );
+          const methodBody = om.body;
+          const fnAbs = absFunction(paramNames, {
+            body: methodBody,
+            apply: (args) => {
+              let e2 = env;
+              for (let i = 0; i < paramNames.length; i++) {
+                e2 = withVar(e2, paramNames[i], args[i] ?? unknown);
+              }
+              const r = evalNode(methodBody, e2, phi2, budget);
+              return r.value;
+            }
+          });
+          pending[key2] = { value: fnAbs };
+          continue;
+        }
+        if (p.type !== "ObjectProperty") continue;
+        const op = p;
+        const keyNode = op.key;
         let key;
         if (keyNode && keyNode.type === "Identifier") key = keyNode.name;
         if (keyNode && keyNode.type === "StringLiteral") key = keyNode.value;
-        if (!key || !p.value) continue;
-        pending[key] = { value: evalNode(p.value, env, phi2, budget).value };
+        if (!key || !op.value) continue;
+        pending[key] = { value: evalNode(op.value, env, phi2, budget).value };
       }
       acc = flushPending(acc);
       return ok2(acc, phi2, env);
@@ -4446,6 +5391,16 @@ function evalBinary(node, env, phi2, budget) {
       if (eq2 !== void 0) return ok2(boolLit(!eq2), phi2, env);
       return ok2(cmp("ne", l, r, phi2), phi2, env);
     }
+    case "==": {
+      const eq2 = looseEqAbs(l, r);
+      if (eq2 !== void 0) return ok2(boolLit(eq2), phi2, env);
+      return ok2(unknown, phi2, env);
+    }
+    case "!=": {
+      const eq2 = looseEqAbs(l, r);
+      if (eq2 !== void 0) return ok2(boolLit(!eq2), phi2, env);
+      return ok2(unknown, phi2, env);
+    }
     case "/":
       return ok2(leakIfNeeded(div(l, r, phi2), budget, "div"), phi2, env);
     case "%":
@@ -4737,7 +5692,7 @@ function evalCall(node, env, phi2, budget) {
         } else if (obj2.shape.k === "arr") {
           applyUnaryCallback(fnNode, obj2.shape.element, env, phi2, budget);
         }
-        return ok2(undefAbs(), phi2, env);
+        return ok2(undefAbs2(), phi2, env);
       }
       if ((method === "some" || method === "every") && rawArgs.length >= 1) {
         const fnNode = rawArgs[0];
@@ -4754,7 +5709,7 @@ function evalCall(node, env, phi2, budget) {
         const fnNode = rawArgs[0];
         const elem = obj2.shape.k === "arr" ? obj2.shape.element : obj2.shape.k === "tuple" ? obj2.shape.elements[0] ?? unknown : unknown;
         applyUnaryCallback(fnNode, elem, env, phi2, budget);
-        return ok2(joinAbs(elem, undefAbs()), phi2, env);
+        return ok2(joinAbs(elem, undefAbs2()), phi2, env);
       }
       {
         const loc = node.loc ? [node.loc.start.line, node.loc.start.column] : void 0;
@@ -4819,7 +5774,16 @@ function applyAbsFn(fnVal, args, env, phi2, budget) {
   const label = fnVal.shape.name ?? "anonymous";
   if (!enterCall(key, label)) return truncatedAbs();
   try {
-    if (impl.apply) return impl.apply(args);
+    if (impl.apply) {
+      try {
+        return impl.apply(args);
+      } catch (e) {
+        if (e && typeof e === "object" && e.name === "NudoReturn") {
+          return e.absValue;
+        }
+        throw e;
+      }
+    }
     const base = impl.env ?? env;
     let local = { vars: new Map(base.vars), fns: base.fns, hofCollect: env.hofCollect };
     if (base.classes) {
@@ -4939,18 +5903,29 @@ function evalFor(node, env, phi2, budget) {
     const r = evalNode(node.init, local, phi2, budget);
     local = r.env;
   }
+  const entry = local;
   let acc = unknown;
+  let exitEnv;
+  let sawAbstractTest = false;
   for (let i = 0; i < MAX_LOOP_ITERS; i++) {
     if (node.test) {
       const t = evalNode(node.test, local, phi2, budget);
       const lv = litValue(t.value);
-      if (lv === false || lv === null || lv === void 0) break;
+      if (lv === false || lv === null || lv === void 0) {
+        exitEnv = exitEnv ? joinEnvs(exitEnv, local, entry) : local;
+        break;
+      }
+      if (lv !== true) {
+        sawAbstractTest = true;
+        exitEnv = exitEnv ? joinEnvs(exitEnv, local, entry) : local;
+      }
     }
     const bodyR = evalInConditionalFlow(() => evalNode(node.body, local, phi2, budget));
     if (bodyR.returned) return bodyR;
     if (bodyR.threw) return bodyR;
     if (bodyR.brk) {
       local = bodyR.env;
+      exitEnv = exitEnv ? joinEnvs(exitEnv, local, entry) : local;
       break;
     }
     local = bodyR.env;
@@ -4960,25 +5935,42 @@ function evalFor(node, env, phi2, budget) {
       local = u.env;
     }
   }
-  return ok2(acc, phi2, local);
+  if (sawAbstractTest) {
+    exitEnv = exitEnv ? joinEnvs(exitEnv, local, entry) : local;
+  }
+  return ok2(acc, phi2, exitEnv ?? local);
 }
 function evalWhile(node, env, phi2, budget) {
   let local = env;
+  const entry = local;
   let acc = unknown;
+  let exitEnv;
+  let sawAbstractTest = false;
   for (let i = 0; i < MAX_LOOP_ITERS; i++) {
     const t = evalNode(node.test, local, phi2, budget);
     const lv = litValue(t.value);
-    if (lv === false || lv === null || lv === void 0) break;
+    if (lv === false || lv === null || lv === void 0) {
+      exitEnv = exitEnv ? joinEnvs(exitEnv, local, entry) : local;
+      break;
+    }
+    if (lv !== true) {
+      sawAbstractTest = true;
+      exitEnv = exitEnv ? joinEnvs(exitEnv, local, entry) : local;
+    }
     const bodyR = evalInConditionalFlow(() => evalNode(node.body, local, phi2, budget));
     if (bodyR.returned || bodyR.threw) return bodyR;
     if (bodyR.brk) {
       local = bodyR.env;
+      exitEnv = exitEnv ? joinEnvs(exitEnv, local, entry) : local;
       break;
     }
     local = bodyR.env;
     acc = joinAbs(acc, bodyR.value);
   }
-  return ok2(acc, phi2, local);
+  if (sawAbstractTest) {
+    exitEnv = exitEnv ? joinEnvs(exitEnv, local, entry) : local;
+  }
+  return ok2(acc, phi2, exitEnv ?? local);
 }
 function evalDoWhile(node, env, phi2, budget) {
   let local = env;
@@ -5009,13 +6001,50 @@ function evalForOf(node, env, phi2, budget) {
     );
     if (promoted) iterVal = promoted;
   }
-  const elements = iterVal.shape.k === "arr" ? [iterVal.shape.element] : iterVal.shape.k === "tuple" ? iterVal.shape.elements : iterVal.shape.k === "sum" ? iterVal.shape.members.flatMap(
-    (m) => m.shape.k === "arr" ? [m.shape.element] : m.shape.k === "tuple" ? m.shape.elements : []
-  ) : [unknown];
-  if (elements.length === 0) elements.push(unknown);
+  const shape = iterVal.shape;
+  const isTuple = shape.k === "tuple";
+  const isArr = shape.k === "arr";
+  let elements = [];
+  if (isArr) {
+    elements = [shape.element];
+  } else if (isTuple) {
+    elements = [...shape.elements];
+  } else if (shape.k === "sum") {
+    elements = shape.members.flatMap(
+      (m) => m.shape.k === "arr" ? [m.shape.element] : m.shape.k === "tuple" ? [...m.shape.elements] : []
+    );
+  } else {
+    elements = [unknown];
+  }
   const left = node.left;
   const bindName = left.type === "Identifier" ? left.name : left.type === "VariableDeclaration" ? left.declarations[0]?.id?.name : void 0;
   if (!bindName) return ok2(unknown, phi2, env);
+  if (isTuple && elements.length === 0) {
+    return ok2(unknown, phi2, env);
+  }
+  const unbounded = !isTuple;
+  if (unbounded) {
+    let cur = env;
+    let joinedEnv = env;
+    let joinedVal = unknown;
+    const el = elements.length > 0 ? elements[0] : unknown;
+    const n2 = elements.length > 0 || isArr || shape.k === "sum" ? MAX_LOOP_ITERS : 0;
+    for (let i = 0; i < n2; i++) {
+      cur = withVar(cur, bindName, el);
+      const bodyR = evalInConditionalFlow(() => evalNode(node.body, cur, phi2, budget));
+      if (bodyR.returned || bodyR.threw) return bodyR;
+      if (bodyR.brk) {
+        cur = bodyR.env;
+        joinedEnv = joinEnvs(joinedEnv, cur, env);
+        break;
+      }
+      cur = bodyR.env;
+      joinedEnv = joinEnvs(joinedEnv, cur, env);
+      joinedVal = joinAbs(joinedVal, bodyR.value);
+    }
+    joinedEnv = joinEnvs(joinedEnv, cur, env);
+    return ok2(joinedVal, phi2, joinedEnv);
+  }
   let local = env;
   let acc = unknown;
   const n = Math.min(elements.length, MAX_LOOP_ITERS);
@@ -5053,6 +6082,20 @@ function evalTry(node, env, phi2, budget) {
       if (node.finalizer) evalNode(node.finalizer, local, curPhi, budget);
       return { value: catchR.value, phi: curPhi, env: local, threw: true };
     }
+  } else if (tryR.partialThrow && node.handler) {
+    const param = node.handler.param && node.handler.param.type === "Identifier" ? node.handler.param.name : void 0;
+    let catchEnv = env;
+    if (param) catchEnv = withVar(env, param, tryR.throwValue ?? tryR.value);
+    const catchR = evalNode(node.handler.body, catchEnv, phi2, budget);
+    value = joinAbs(tryR.value, catchR.value);
+    local = joinEnvs(tryR.env, catchR.env, env);
+    curPhi = catchR.phi;
+    if (catchR.returned && tryR.returned) {
+      return { value, phi: curPhi, env: local, returned: true };
+    }
+    if (catchR.threw && tryR.threw) {
+      return { value, phi: curPhi, env: local, threw: true };
+    }
   } else if (tryR.returned) {
     if (node.finalizer) evalNode(node.finalizer, local, curPhi, budget);
     return tryR;
@@ -5065,7 +6108,13 @@ function evalTry(node, env, phi2, budget) {
     if (fR.returned || fR.threw) return fR;
     local = fR.env;
   }
-  return { value, phi: curPhi, env: local, returned: tryR.returned };
+  return {
+    value,
+    phi: curPhi,
+    env: local,
+    returned: tryR.returned,
+    ...tryR.partialReturn || tryR.partialThrow ? { partialReturn: tryR.partialReturn } : {}
+  };
 }
 function evalVarDecl(node, env, phi2, budget) {
   let local = env;
@@ -5105,12 +6154,157 @@ function evalIf(node, env, phi2, budget) {
     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 };
+    const bothRet = !!a.returned && !!b.returned;
+    const eitherRet = !!a.returned || !!b.returned;
+    const contEnv = a.returned && !b.returned ? b.env : b.returned && !a.returned ? a.env : a.threw && !b.threw ? b.env : b.threw && !a.threw ? a.env : joinEnvs(a.env, b.env, env);
+    return {
+      value: joinAbs(a.value, b.value),
+      phi: phi2,
+      env: contEnv,
+      ...bothRet ? { returned: true } : eitherRet ? { partialReturn: true } : {},
+      ...a.threw && b.threw ? { threw: true, throwValue: joinAbs(a.value, b.value) } : {},
+      ...(a.threw || b.threw) && !(a.threw && b.threw) ? { partialThrow: true, throwValue: a.threw ? a.value : b.value } : {}
+    };
   }
-  if (a.returned || a.threw) {
+  if (a.returned && a.threw) {
     return { value: a.value, phi: phi2, env, partialReturn: true };
   }
-  return { value: unknown, phi: phi2, env };
+  if (a.returned || a.threw) {
+    return {
+      value: a.value,
+      phi: phi2,
+      env,
+      ...a.returned ? { partialReturn: true } : {},
+      ...a.threw ? { partialThrow: true, throwValue: a.value } : {}
+    };
+  }
+  return { value: unknown, phi: phi2, env: joinEnvs(a.env, env, env) };
+}
+function evalSwitch(node, env, phi2, budget) {
+  const stmtCompletes = (s) => {
+    if (!s) return false;
+    switch (s.type) {
+      case "BreakStatement":
+      case "ReturnStatement":
+      case "ThrowStatement":
+      case "ContinueStatement":
+        return true;
+      case "BlockStatement":
+        return stmtCompletes(s.body[s.body.length - 1]);
+      case "IfStatement": {
+        const ifs = s;
+        return ifs.alternate != null && stmtCompletes(ifs.consequent) && stmtCompletes(ifs.alternate);
+      }
+      default:
+        return false;
+    }
+  };
+  const pre = [];
+  let pending = [];
+  for (const c of node.cases) {
+    if (c.test == null) {
+      if (pending.length > 0 && c.consequent.length > 0) {
+        pre.push({ tests: pending, body: [...c.consequent], isDefault: false });
+        pending = [];
+      }
+      pre.push({ tests: [], body: [...c.consequent], isDefault: true });
+      continue;
+    }
+    if (c.consequent.length === 0) {
+      pending.push(c.test);
+      continue;
+    }
+    pre.push({ tests: [...pending, c.test], body: [...c.consequent], isDefault: false });
+    pending = [];
+  }
+  if (pending.length > 0) pre.push({ tests: pending, body: [], isDefault: false });
+  const arms = pre.map((a) => ({ ...a, tests: [...a.tests], body: [...a.body] }));
+  for (let i = 0; i < arms.length; i++) {
+    const arm = arms[i];
+    const body = [...arm.body];
+    let j = i + 1;
+    while (j < arms.length && !stmtCompletes(body[body.length - 1])) {
+      body.push(...arms[j].body);
+      if (stmtCompletes(body[body.length - 1])) break;
+      j++;
+    }
+    arm.body = body;
+  }
+  const runBody = (body, e) => {
+    let local = e;
+    let value2 = unknown;
+    for (const s of body) {
+      const r = evalInConditionalFlow(() => evalNode(s, local, phi2, budget));
+      local = r.env;
+      value2 = r.value;
+      if (r.returned || r.threw || r.brk) return { ...r, env: local, value: value2 };
+    }
+    return { value: value2, phi: phi2, env: local };
+  };
+  const disc = evalNode(node.discriminant, env, phi2, budget).value;
+  const dlv = litValue(disc);
+  const hasDefault = arms.some((a) => a.isDefault);
+  const testLit = (t) => {
+    if (t == null) return null;
+    return litValue(evalNode(t, env, phi2, budget).value);
+  };
+  if (dlv !== void 0) {
+    let matched = null;
+    let sawAbstractTest = false;
+    for (const arm of arms) {
+      if (arm.isDefault) continue;
+      let hit = false;
+      for (const t of arm.tests) {
+        const tv = testLit(t);
+        if (tv === null) continue;
+        if (tv === void 0) {
+          sawAbstractTest = true;
+          continue;
+        }
+        if (tv === dlv) {
+          hit = true;
+          break;
+        }
+      }
+      if (hit) {
+        matched = arm;
+        break;
+      }
+    }
+    if (!sawAbstractTest) {
+      if (matched) return runBody(matched.body, env);
+      const dflt = arms.find((a) => a.isDefault);
+      if (dflt) return runBody(dflt.body, env);
+      return ok2(unknown, phi2, env);
+    }
+  }
+  const results = [];
+  if (!hasDefault) results.push(ok2(unknown, phi2, env));
+  for (const arm of arms) {
+    if (arm.body.length === 0 && !arm.isDefault) continue;
+    results.push(runBody(arm.body, env));
+  }
+  if (results.length === 0) return ok2(unknown, phi2, env);
+  let value = results[0].value;
+  let envOut = results[0].env;
+  let allRet = !!results[0].returned;
+  let anyRet = !!results[0].returned;
+  let anyThrew = !!results[0].threw;
+  for (let i = 1; i < results.length; i++) {
+    const r = results[i];
+    value = joinAbs(value, r.value);
+    envOut = joinEnvs(envOut, r.env, env);
+    allRet = allRet && !!r.returned;
+    anyRet = anyRet || !!r.returned;
+    anyThrew = anyThrew || !!r.threw;
+  }
+  return {
+    value,
+    phi: phi2,
+    env: envOut,
+    ...allRet ? { returned: true } : anyRet ? { partialReturn: true } : {},
+    ...anyThrew ? { partialThrow: true } : {}
+  };
 }
 function analyzeFn(source, fnName, args, phi2 = pTrue, budget, file, modules) {
   return evalSource(source, { fn: fnName, args }, { phi: phi2, budget, file, modules }).value;
@@ -5281,7 +6475,7 @@ function $callNamed(name, fn, args, loc, argLocs) {
   try {
     if (typeof fn === "function") {
       const g = GLOBAL_FNS.has(name) && fn === globalThis[name] ? evalGlobalFn(name, args) : void 0;
-      result = g ?? fn(...args);
+      result = g ?? callAtFunctionBoundary(() => fn(...args));
     } else if (fn && typeof fn === "object" && "shape" in fn) {
       result = $call(fn, args);
     }
@@ -5352,6 +6546,14 @@ function $ne(a, b) {
   const r = strictEqAbs(a, b);
   return r === void 0 ? bool() : boolLit(!r);
 }
+function $eqLoose(a, b) {
+  const r = looseEqAbs(a, b);
+  return r === void 0 ? bool() : boolLit(r);
+}
+function $neLoose(a, b) {
+  const r = looseEqAbs(a, b);
+  return r === void 0 ? bool() : boolLit(!r);
+}
 function $lt(a, b) {
   return cmp("lt", a, b, phi);
 }
@@ -5375,13 +6577,28 @@ function asAbsVal(v2) {
     const params = Array.from({ length: n }, (_, i) => `arg${i}`);
     return absFunction(params, {
       body: noBody,
-      apply: (args) => v2(...args)
+      // 与 $fnVal / $callNamed 同边界：callee 的 NudoReturn 不得冒泡成 caller
+      apply: (args) => callAtFunctionBoundary(() => v2(...args))
     });
   }
   return $lit(v2);
 }
-function $fnVal(params, impl) {
-  return absFunction(params, { body: noBody, apply: (args) => impl(...args) });
+function callAtFunctionBoundary(body) {
+  return runWithLoopExits(() => {
+    try {
+      return body();
+    } catch (e) {
+      if (isNudoReturn(e)) return e.absValue;
+      throw e;
+    }
+  });
+}
+function $fnVal(params, impl, opts) {
+  return absFunction(params, {
+    body: noBody,
+    apply: (args) => callAtFunctionBoundary(() => impl(...args)),
+    ...opts?.bindThis ? { bindThis: true } : {}
+  });
 }
 function $lit(v2) {
   if (v2 && typeof v2 === "object" && "shape" in v2 && "conf" in v2) {
@@ -5436,12 +6653,163 @@ function isDefinitelyFalse(a) {
 function undef() {
   return abs({ k: "unknown" }, { op: "lit", value: void 0 }, pTrue, "exact");
 }
+var loopExitsAls = new AsyncLocalStorage2();
+var throwExitsAls = new AsyncLocalStorage2();
+var tryMarksAls = new AsyncLocalStorage2();
+function runWithLoopExits(body) {
+  return loopExitsAls.run(
+    [],
+    () => throwExitsAls.run([], () => tryMarksAls.run([], body))
+  );
+}
+function takeLoopExits() {
+  return loopExitsAls.getStore() ?? [];
+}
+function takeThrowExits() {
+  return throwExitsAls.getStore() ?? [];
+}
+function pushLoopExit(v2) {
+  loopExitsAls.getStore()?.push(v2);
+}
+function pushThrowExit(v2) {
+  throwExitsAls.getStore()?.push(v2);
+}
+function $pushLoopExit(v2) {
+  pushLoopExit(v2);
+}
+function $tryMark() {
+  const store = throwExitsAls.getStore();
+  const m = store?.length ?? 0;
+  tryMarksAls.getStore()?.push(m);
+  return m;
+}
+function $tryCurrentMark() {
+  const stack = tryMarksAls.getStore();
+  return stack && stack.length > 0 ? stack[stack.length - 1] : 0;
+}
+function $tryPopMark() {
+  tryMarksAls.getStore()?.pop();
+}
+function $tryTakeSince(mark) {
+  const store = throwExitsAls.getStore();
+  if (!store) return [];
+  return store.splice(Math.min(mark, store.length));
+}
+var yieldStack = [];
+var genPathSensitive = 0;
+var genJoinOverride = null;
+function withIsolatedYields(fn) {
+  const top = yieldStack[yieldStack.length - 1];
+  if (!top) return { v: fn(), ys: null };
+  const armYs = [];
+  yieldStack[yieldStack.length - 1] = armYs;
+  try {
+    return { v: fn(), ys: armYs };
+  } finally {
+    yieldStack[yieldStack.length - 1] = top;
+  }
+}
+function mergeArmYields(armYsList) {
+  const top = yieldStack[yieldStack.length - 1];
+  if (!top || armYsList.length === 0) return;
+  const concrete = armYsList.filter((x) => x !== null);
+  if (concrete.length === 0) return;
+  if (concrete.length === 1) {
+    top.push(...concrete[0]);
+    return;
+  }
+  let joined = null;
+  for (const ys of concrete) {
+    joined = joined ? joinAbs(joined, $arr(ys)) : $arr(ys);
+  }
+  genPathSensitive++;
+  if (joined) genJoinOverride = joined;
+  for (const ys of concrete) top.push(...ys);
+}
+function runForkArm(arm, exits) {
+  try {
+    return { kind: "val", v: asAbsVal(arm()) };
+  } catch (e) {
+    if (isNudoReturn(e)) {
+      exits?.push(e.absValue);
+      return { kind: "ret", v: e.absValue };
+    }
+    if (isNudoThrow(e)) {
+      pushThrowExit(e.absValue);
+      return { kind: "throw", v: e.absValue };
+    }
+    throw e;
+  }
+}
+function settleForkArms(a, b, exits) {
+  const throws = [a, b].filter((r) => r.kind === "throw");
+  const nonThrow = [a, b].filter((r) => r.kind !== "throw");
+  if (nonThrow.length === 0) {
+    throw new NudoThrow(throws.map((t) => t.v).reduce((x, y) => joinAbs(x, y)));
+  }
+  const first = nonThrow[0];
+  const second = nonThrow[1] ?? first;
+  if (first.kind === "ret" && second.kind === "ret") {
+    throw new NudoReturn(joinAbs(first.v, second.v));
+  }
+  if (nonThrow.length === 1) {
+    if (first.kind === "ret") {
+      if (!exits) throw new NudoReturn(first.v);
+      return undef();
+    }
+    return first.v;
+  }
+  if (first.kind === "ret") {
+    if (!exits) throw new NudoReturn(first.v);
+    return second.kind === "val" ? second.v : undef();
+  }
+  if (second.kind === "ret") {
+    if (!exits) throw new NudoReturn(second.v);
+    return first.v;
+  }
+  return joinAbs(first.v, second.v);
+}
 function $fork(test, consequent, alternate) {
   if (isDefinitelyTrue(test)) return asAbsVal(consequent());
   if (isDefinitelyFalse(test)) return alternate ? asAbsVal(alternate()) : undef();
-  const a = asAbsVal(consequent());
-  const b = alternate ? asAbsVal(alternate()) : undef();
-  return joinAbs(a, b);
+  const exits = loopExitsAls.getStore();
+  beginCollectionFork();
+  const arms = [];
+  const armYsList = [];
+  let a;
+  let b;
+  try {
+    pushCollectionArm();
+    try {
+      const r = withIsolatedYields(() => runForkArm(consequent, exits));
+      a = r.v;
+      armYsList.push(r.ys);
+    } finally {
+      arms.push(popCollectionArm());
+    }
+    if (alternate) {
+      pushCollectionArm();
+      try {
+        const r = withIsolatedYields(() => runForkArm(alternate, exits));
+        b = r.v;
+        armYsList.push(r.ys);
+      } finally {
+        arms.push(popCollectionArm());
+      }
+    } else {
+      pushCollectionArm();
+      try {
+        b = { kind: "val", v: undef() };
+        armYsList.push(null);
+      } finally {
+        arms.push(popCollectionArm());
+      }
+    }
+  } finally {
+    endCollectionFork(arms);
+    if (yieldStack.length > 0) mergeArmYields(armYsList);
+  }
+  return settleForkArms(a, b, exits);
 }
 var DEFAULT_MAX_LOOP_ITERS = 8;
 function* $forIter(init, test, step, body, maxIters = DEFAULT_MAX_LOOP_ITERS) {
@@ -5457,30 +6825,67 @@ function* $forIter(init, test, step, body, maxIters = DEFAULT_MAX_LOOP_ITERS) {
     s = step(afterBody);
   }
 }
-function $for(init, test, step, body, maxIters = DEFAULT_MAX_LOOP_ITERS) {
+function $for(init, test, step, body, maxIters = DEFAULT_MAX_LOOP_ITERS, opts) {
   let state = init;
   let exitJoin;
+  let extJoin;
+  const pack = opts?.pack;
+  const unpack = opts?.unpack;
+  const snapCounter = () => {
+    exitJoin = exitJoin ? joinAbs(exitJoin, state) : state;
+  };
+  const snapExt = () => {
+    if (!pack) return;
+    const p = pack();
+    extJoin = extJoin ? joinAbs(extJoin, p) : p;
+  };
+  const applyExtJoin = () => {
+    if (!extJoin || !pack || !unpack) return;
+    unpack(joinAbs(extJoin, pack()));
+  };
   for (let i = 0; i < maxIters; i++) {
     const t = test(state);
     if (isDefinitelyFalse(t)) {
-      return exitJoin ? joinAbs(exitJoin, state) : state;
+      snapCounter();
+      snapExt();
+      applyExtJoin();
+      return exitJoin ?? state;
     }
-    if (!isDefinitelyTrue(t)) {
-      exitJoin = exitJoin ? joinAbs(exitJoin, state) : state;
+    const abstractTest = !isDefinitelyTrue(t);
+    if (abstractTest) {
+      snapCounter();
+      snapExt();
+    }
+    let afterBody;
+    try {
+      afterBody = body(state);
+    } catch (e) {
+      if (isNudoReturn(e) || isNudoThrow(e)) throw e;
+      throw e;
     }
-    const afterBody = body(state);
     const next = step(afterBody);
+    if (abstractTest) {
+      state = afterBody;
+      snapExt();
+    }
     if (i > 0) {
       const nv = litValue(next);
       const sv = litValue(state);
       const stuck = nv !== void 0 && sv !== void 0 && nv === sv || nv === void 0 && sv === void 0 && leqAbs(next, state).ok;
       if (stuck) {
-        return exitJoin ? joinAbs(exitJoin, next) : next;
+        state = next;
+        snapCounter();
+        snapExt();
+        applyExtJoin();
+        return exitJoin ?? next;
       }
     }
     state = next;
   }
-  return exitJoin ? joinAbs(exitJoin, state) : state;
+  snapCounter();
+  snapExt();
+  applyExtJoin();
+  return exitJoin ?? state;
 }
 function tupleOrWiden(els, conf) {
   if (shouldWidenArrayLiteral(els.length)) {
@@ -5496,6 +6901,99 @@ function tupleOrWiden(els, conf) {
 function $arr(items) {
   return tupleOrWiden(items.map(asAbsVal), "exact");
 }
+var ARR_MUTATORS = /* @__PURE__ */ new Set([
+  "push",
+  "unshift",
+  "pop",
+  "shift",
+  "splice",
+  "reverse",
+  "sort"
+]);
+function isArrMutator(name) {
+  return ARR_MUTATORS.has(name);
+}
+function $arrMutContainer(arr, method, args) {
+  const shape = arr.shape;
+  if (shape.k !== "tuple" && shape.k !== "arr") return arr;
+  const vals = args.map((a) => asAbsVal(a));
+  const asArrEl = (els) => els.length > 0 ? els.reduce((x, y) => joinAbs(x, y)) : unknown;
+  if (method === "push" || method === "unshift") {
+    if (shape.k === "tuple") {
+      const els = method === "push" ? [...shape.elements, ...vals] : [...vals, ...shape.elements];
+      const conf = vals.reduce(
+        (acc, v2) => confJoin(acc, v2.conf),
+        arr.conf
+      );
+      return abs(
+        { k: "tuple", elements: els },
+        void 0,
+        void 0,
+        conf
+      );
+    }
+    const el = vals.reduce((acc, v2) => joinAbs(acc, v2), shape.element);
+    return abs({ k: "arr", element: el }, void 0, void 0, confJoin(arr.conf, "path"));
+  }
+  if (method === "pop") {
+    if (shape.k === "tuple") {
+      if (shape.elements.length === 0) return arr;
+      return abs(
+        { k: "tuple", elements: shape.elements.slice(0, -1) },
+        void 0,
+        void 0,
+        arr.conf
+      );
+    }
+    return arr;
+  }
+  if (method === "shift") {
+    if (shape.k === "tuple") {
+      if (shape.elements.length === 0) return arr;
+      return abs(
+        { k: "tuple", elements: shape.elements.slice(1) },
+        void 0,
+        void 0,
+        arr.conf
+      );
+    }
+    return arr;
+  }
+  if (method === "splice") {
+    if (shape.k === "tuple") {
+      return abs(
+        { k: "arr", element: asArrEl(shape.elements) },
+        void 0,
+        void 0,
+        confJoin(arr.conf, "path")
+      );
+    }
+    return arr;
+  }
+  if (method === "reverse") {
+    if (shape.k === "tuple") {
+      return abs(
+        { k: "tuple", elements: [...shape.elements].reverse() },
+        void 0,
+        void 0,
+        arr.conf
+      );
+    }
+    return arr;
+  }
+  if (method === "sort") {
+    if (shape.k === "tuple") {
+      return abs(
+        { k: "arr", element: asArrEl(shape.elements) },
+        void 0,
+        void 0,
+        confJoin(arr.conf, "path")
+      );
+    }
+    return arr;
+  }
+  return arr;
+}
 function $idx(a, i) {
   const iv = litValue(i);
   if (a.shape.k === "tuple") {
@@ -5511,6 +7009,22 @@ function $idx(a, i) {
   if (a.shape.k === "sum") {
     return a.shape.members.map((m) => $idx(m, i)).reduce((x, y) => joinAbs(x, y));
   }
+  if (a.shape.k === "obj" || a.shape.k === "brand" && a.shape.shape.shape.k === "obj") {
+    const objShape = a.shape.k === "obj" ? a.shape : a.shape.shape.shape;
+    const slots = Object.values(objShape.slots).map((s) => s.value);
+    if (slots.length === 0) return objShape.open ? unknown : undef();
+    const joinSlotsWithUndef = () => joinAbs(slots.reduce((x, y) => joinAbs(x, y)), undef());
+    if (typeof iv === "string" || typeof iv === "number" || typeof iv === "boolean") {
+      const slot = objShape.slots[String(iv)];
+      if (slot) return slot.value;
+      if (objShape.open) return unknown;
+      return undef();
+    }
+    if (objShape.open && slots.length > 0) {
+      return joinAbs(slots.reduce((x, y) => joinAbs(x, y)), unknown);
+    }
+    return joinSlotsWithUndef();
+  }
   const sv = litValue(a);
   if (typeof sv === "string") {
     if (typeof iv === "number" && Number.isInteger(iv)) {
@@ -5570,6 +7084,35 @@ function $obj(slots) {
 function $spread(a, b) {
   return spread(asAbsVal(a), asAbsVal(b));
 }
+function $objRest(o, keys) {
+  o = asAbsVal(o);
+  if (o.shape.k === "sum") {
+    return o.shape.members.map((m) => $objRest(m, keys)).reduce((a, b) => joinAbs(a, b));
+  }
+  if (!isObj(o)) return unknown;
+  const drop = new Set(keys);
+  const slots = {};
+  let openRest = o.shape.open === true;
+  for (const [k, s] of Object.entries(o.shape.slots)) {
+    if (drop.has(k)) continue;
+    slots[k] = s;
+  }
+  if (o.shape.open) openRest = true;
+  const shape = { k: "obj", slots };
+  if (openRest) shape.open = true;
+  return { shape, conf: o.conf === "exact" ? "exact" : confJoin(o.conf, "partial") };
+}
+function $arrRest(a, start) {
+  a = asAbsVal(a);
+  if (a.shape.k === "sum") {
+    return a.shape.members.map((m) => $arrRest(m, start)).reduce((x, y) => joinAbs(x, y));
+  }
+  if (a.shape.k === "tuple") {
+    return tupleOrWiden(a.shape.elements.slice(start), a.conf);
+  }
+  if (a.shape.k === "arr") return a;
+  return unknown;
+}
 function $concat(a, b) {
   a = asAbsVal(a);
   b = asAbsVal(b);
@@ -5604,20 +7147,49 @@ function $concat(a, b) {
 function $elems(a) {
   if (a.shape.k === "tuple") return [...a.shape.elements];
   if (a.shape.k === "arr") return [a.shape.element];
+  if (isSetAbs(a)) return setElementsAbs(a);
+  if (isMapAbs(a)) return mapEntriesAbs(a);
   return [unknown];
 }
-function $forOf(iterable, body, maxIters = DEFAULT_MAX_LOOP_ITERS) {
+function $forOf(iterable, body, maxIters = DEFAULT_MAX_LOOP_ITERS, opts) {
+  const pack = opts?.pack;
+  const unpack = opts?.unpack;
+  let exitJoin;
+  const snapExit = () => {
+    if (!pack) return;
+    const s = pack();
+    exitJoin = exitJoin ? joinAbs(exitJoin, s) : s;
+  };
+  const applyExitJoin = () => {
+    if (!exitJoin || !pack || !unpack) return;
+    unpack(joinAbs(exitJoin, pack()));
+  };
+  const shape = iterable.shape;
   const items = $elems(iterable);
-  const n = Math.min(items.length || maxIters, maxIters);
+  const knownLen = shape.k === "tuple" ? shape.elements.length : collectionExactLen(iterable);
+  const unbounded = knownLen === void 0;
+  if (unbounded) snapExit();
+  const n = knownLen !== void 0 ? Math.min(knownLen, maxIters) : items.length > 0 ? maxIters : 0;
   for (let i = 0; i < n; i++) {
     const item = items.length > 0 ? items[Math.min(i, items.length - 1)] : unknown;
-    body(item, abs(
-      { k: "prim", type: "number" },
-      { op: "lit", value: i },
-      pTrue,
-      "exact"
-    ));
+    try {
+      body(
+        item,
+        abs(
+          { k: "prim", type: "number" },
+          { op: "lit", value: i },
+          pTrue,
+          "exact"
+        )
+      );
+    } catch (e) {
+      if (isNudoReturn(e) || isNudoThrow(e)) throw e;
+      throw e;
+    }
+    if (unbounded) snapExit();
   }
+  if (unbounded && n === 0) snapExit();
+  applyExitJoin();
 }
 function namespaceNameOf(v2) {
   if (typeof v2 !== "object" && typeof v2 !== "function") return void 0;
@@ -5665,11 +7237,19 @@ function $get(o, key, opts) {
     }
     return unknown;
   }
-  if (o.shape.k === "brand") return $get(o.shape.shape, key, opts);
+  if (o.shape.k === "brand") {
+    if (key === "size" && o.shape.name === "Map") return mapSizeAbs(o);
+    if (key === "size" && o.shape.name === "Set") return setSizeAbs(o);
+    return $get(o.shape.shape, key, opts);
+  }
   if (isObj(o)) {
     const slot = o.shape.slots[key];
-    if (slot) return slot.value;
+    if (slot) {
+      if (slot.optional) return joinAbs(slot.value, undef());
+      return slot.value;
+    }
     if (o.shape.open) return unknown;
+    noteObjSlotMissing(o, key);
     return undef();
   }
   if (o.shape.k === "sum") {
@@ -5678,6 +7258,7 @@ function $get(o, key, opts) {
   }
   if (!opts?.silent) {
     noteUnknownMemberMissing(o, key, "property");
+    noteObjSlotMissing(o, key);
   }
   return unknown;
 }
@@ -5725,12 +7306,52 @@ function $while(init, test, step, maxIters = DEFAULT_MAX_LOOP_ITERS) {
   }
   return exitJoin ? joinAbs(exitJoin, state) : state;
 }
-function $whileSeq(test, body, maxIters = DEFAULT_MAX_LOOP_ITERS) {
+function $whileSeq(test, body, maxIters = DEFAULT_MAX_LOOP_ITERS, opts) {
+  const pack = opts?.pack;
+  const unpack = opts?.unpack;
+  let exitJoin;
+  const snapExit = () => {
+    if (!pack) return;
+    const s = pack();
+    exitJoin = exitJoin ? joinAbs(exitJoin, s) : s;
+  };
+  const applyExitJoin = () => {
+    if (!exitJoin || !pack || !unpack) return;
+    unpack(joinAbs(exitJoin, pack()));
+  };
   for (let i = 0; i < maxIters; i++) {
     const t = test();
-    if (isDefinitelyFalse(t)) return;
-    body();
+    if (isDefinitelyFalse(t)) {
+      applyExitJoin();
+      return;
+    }
+    if (!isDefinitelyTrue(t)) snapExit();
+    try {
+      body();
+    } catch (e) {
+      if (isNudoReturn(e) || isNudoThrow(e)) throw e;
+      throw e;
+    }
+  }
+  snapExit();
+  applyExitJoin();
+}
+var NudoReturn = class extends Error {
+  absValue;
+  constructor(absValue) {
+    super("nudo:return");
+    this.name = "NudoReturn";
+    this.absValue = absValue;
   }
+};
+function $loopReturn(v2) {
+  throw new NudoReturn(v2);
+}
+function isNudoReturn(e) {
+  return e instanceof NudoReturn;
+}
+function $rethrowIfNudoReturn(e) {
+  if (isNudoReturn(e)) throw e;
 }
 var NudoThrow = class extends Error {
   absValue;
@@ -5746,11 +7367,35 @@ function $throw(v2) {
 function isNudoThrow(e) {
   return e instanceof NudoThrow;
 }
+function $isForkExit(e) {
+  return isNudoReturn(e) || isNudoThrow(e);
+}
 function $catchVal(e) {
   if (isNudoThrow(e)) return e.absValue;
   if (e instanceof Error) {
+    const name = e.name || "Error";
+    const msgAbs = typeof e.message === "string" ? abs(
+      { k: "prim", type: "string" },
+      { op: "lit", value: e.message },
+      pTrue,
+      "exact"
+    ) : abs({ k: "prim", type: "string" }, void 0, void 0, "path");
     return abs(
-      { k: "brand", name: e.name || "Error", shape: objOf({}) },
+      {
+        k: "brand",
+        name,
+        shape: objOf({
+          name: {
+            value: abs(
+              { k: "prim", type: "string" },
+              { op: "lit", value: name },
+              pTrue,
+              "exact"
+            )
+          },
+          message: { value: msgAbs }
+        })
+      },
       void 0,
       void 0,
       "path"
@@ -5781,16 +7426,28 @@ function $asyncReturn(v2) {
   if (v2.shape.k === "eff") return v2;
   return wrapPromiseAbs(v2);
 }
-var yieldStack = [];
 function $gen(body) {
   const ys = [];
+  const marker = genPathSensitive;
+  const prevOverride = genJoinOverride;
+  genJoinOverride = null;
   yieldStack.push(ys);
   try {
     body();
   } finally {
     yieldStack.pop();
   }
-  return $arr(ys);
+  if (genJoinOverride) {
+    const joined = genJoinOverride;
+    genJoinOverride = prevOverride;
+    return { ...joined, conf: joined.conf === "exact" ? "path" : joined.conf };
+  }
+  genJoinOverride = prevOverride;
+  const arr = $arr(ys);
+  if (genPathSensitive > marker) {
+    return { ...arr, conf: arr.conf === "exact" ? "path" : arr.conf };
+  }
+  return arr;
 }
 function $yield(v2) {
   const top = yieldStack[yieldStack.length - 1];
@@ -5806,10 +7463,63 @@ function $switch(disc, cases, dflt) {
     }
     return dflt ? asAbsVal(dflt()) : undef();
   }
-  const parts = cases.map((c) => asAbsVal(c.run()));
-  if (dflt) parts.push(asAbsVal(dflt()));
-  if (parts.length === 0) return undef();
-  return parts.reduce((a, b) => joinAbs(a, b));
+  const exits = loopExitsAls.getStore();
+  beginCollectionFork();
+  const armOverlays2 = [];
+  const armYsList = [];
+  const runArm = (fn) => {
+    pushCollectionArm();
+    try {
+      const r = withIsolatedYields(() => runForkArm(fn, exits));
+      armYsList.push(r.ys);
+      return r.v;
+    } finally {
+      armOverlays2.push(popCollectionArm());
+    }
+  };
+  const results = [];
+  try {
+    const seenRuns = /* @__PURE__ */ new Set();
+    for (const c of cases) {
+      if (seenRuns.has(c.run)) continue;
+      seenRuns.add(c.run);
+      results.push(runArm(c.run));
+    }
+    if (dflt) {
+      if (!seenRuns.has(dflt)) results.push(runArm(dflt));
+    } else {
+      pushCollectionArm();
+      try {
+        results.push({ kind: "val", v: undef() });
+        armYsList.push(null);
+      } finally {
+        armOverlays2.push(popCollectionArm());
+      }
+    }
+  } finally {
+    endCollectionFork(armOverlays2);
+    if (yieldStack.length > 0) mergeArmYields(armYsList);
+  }
+  if (results.length === 0) return undef();
+  const throws = results.filter((r) => r.kind === "throw");
+  const nonThrow = results.filter((r) => r.kind !== "throw");
+  if (nonThrow.length === 0) {
+    throw new NudoThrow(throws.map((t) => t.v).reduce((x, y) => joinAbs(x, y)));
+  }
+  const allRet = nonThrow.every((r) => r.kind === "ret");
+  if (allRet) {
+    throw new NudoReturn(nonThrow.map((r) => r.v).reduce((a, b) => joinAbs(a, b)));
+  }
+  const valParts = nonThrow.filter((r) => r.kind === "val").map((r) => r.v);
+  if (valParts.length === 0) return undef();
+  return valParts.reduce((a, b) => joinAbs(a, b));
+}
+function $nullishTest(v2) {
+  if (definitelyNotNullishShape(v2.shape)) return boolLit(false);
+  if (isNullishLitAbs(v2)) return boolLit(true);
+  const t = v2.term;
+  if (t?.op === "lit" && t.value !== null && t.value !== void 0) return boolLit(false);
+  return bool();
 }
 
 // src/algebra/exec/transpile.ts
@@ -5824,6 +7534,7 @@ function matchAsOverride(stmt, opts) {
 function normWs(s) {
   return s.replace(/\s+/g, "");
 }
+var switchBodySeq = 0;
 function matchReplacement(node, opts) {
   if (!opts.source || !opts.replacements?.length) return null;
   if (node.start == null || node.end == null || !node.loc) return null;
@@ -5848,7 +7559,9 @@ var BIN_OPS = {
   ">": "$gt",
   ">=": "$ge",
   "===": "$eq",
-  "!==": "$ne"
+  "!==": "$ne",
+  "==": "$eqLoose",
+  "!=": "$neLoose"
 };
 var COMPOUND_OPS = {
   "+=": "$add",
@@ -5921,6 +7634,65 @@ function setPathSrc(p, valSrc) {
 function readPrefix(p, j) {
   return p.layers.slice(0, j + 1).reduce((acc, l) => l.get(acc), p.rootSrc);
 }
+var ARR_MUTATOR_NAMES = /* @__PURE__ */ new Set([
+  "push",
+  "unshift",
+  "splice",
+  "pop",
+  "shift",
+  "reverse",
+  "sort"
+]);
+function emitArrMutatorRebinds(expr, opts, pad) {
+  const lines = [];
+  if (!expr || typeof expr !== "object") return lines;
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const node = n;
+    if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ObjectMethod" || node.type === "ClassMethod") {
+      return;
+    }
+    if (node.type === "LogicalExpression" || node.type === "ConditionalExpression") {
+      return;
+    }
+    if (node.type === "AssignmentExpression" && (node.operator === "||=" || node.operator === "&&=" || node.operator === "??=")) {
+      visit(node.left);
+      return;
+    }
+    if (node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.computed !== true && node.callee.property?.type === "Identifier" && ARR_MUTATOR_NAMES.has(node.callee.property.name)) {
+      const methodName = node.callee.property.name;
+      const argSrcs = (node.arguments ?? []).map(
+        (a) => a.type === "SpreadElement" ? "$lit(undefined)" : isExpression(a) ? transpileExpression(a, opts) : "$lit(undefined)"
+      ).join(", ");
+      const objNode = node.callee.object;
+      if (objNode.type === "Identifier") {
+        const name = objNode.name;
+        lines.push(
+          `${pad}${name} = $arrMutContainer(${name}, ${JSON.stringify(methodName)}, [${argSrcs}]);`
+        );
+      } else if (objNode.type === "MemberExpression" || objNode.type === "ThisExpression") {
+        const path = objNode.type === "MemberExpression" ? memberPathOf(
+          objNode,
+          opts
+        ) : null;
+        if (path) {
+          const recvSrc = readPathSrc(path);
+          const mutSrc = `$arrMutContainer(${recvSrc}, ${JSON.stringify(methodName)}, [${argSrcs}])`;
+          lines.push(`${pad}${path.rootSrc} = ${setPathSrc(path, mutSrc)};`);
+        }
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "range") continue;
+      if (key === "callee" || key === "property") continue;
+      const child = node[key];
+      if (Array.isArray(child)) child.forEach(visit);
+      else if (child && typeof child === "object") visit(child);
+    }
+  };
+  visit(expr);
+  return lines;
+}
 function transpileSource(source, opts = {}) {
   const file = parseSource(source);
   return transpileFile(file, { ...opts, source: opts.source ?? source });
@@ -5929,7 +7701,7 @@ function transpileFile(file, opts = {}) {
   const runtime = opts.runtimeImport ?? "@nudojs/core/exec";
   const lines = [
     `// nudo B-path transpile \u2014 values are Abs; operators are overloaded calls`,
-    `import { $add, $sub, $mul, $div, $mod, $neg, $typeof, $not, $eq, $ne, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $while, $whileSeq, $arr, $idx, $idxSet, $len, $call, $throw, $class, $new, $invoke, $invokeSuper, $super, $async, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal, $regex } from ${JSON.stringify(runtime)};`,
+    `import { $add, $sub, $mul, $div, $mod, $neg, $typeof, $not, $eq, $ne, $eqLoose, $neLoose, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $while, $whileSeq, $arr, $arrMutContainer, $idx, $idxSet, $len, $call, $throw, $loopReturn, $class, $new, $invoke, $invokeSuper, $super, $async, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal, $regex, $rethrowIfNudoReturn, $nullishTest, $tryMark, $tryTakeSince, $tryCurrentMark, $tryPopMark, $pushLoopExit, $objRest, $arrRest, $isForkExit } from ${JSON.stringify(runtime)};`,
     ``
   ];
   for (const stmt of file.program.body) {
@@ -5940,12 +7712,226 @@ function transpileFile(file, opts = {}) {
 function indent(n) {
   return "  ".repeat(n);
 }
+function collectAssignedIds(node, acc) {
+  if (!node || typeof node !== "object") return;
+  const n = node;
+  if (n.type === "AssignmentExpression" && n.left?.type === "Identifier" && n.left.name) {
+    acc.add(n.left.name);
+  }
+  if (n.type === "AssignmentExpression" && n.left?.type === "MemberExpression") {
+    let cur = n.left;
+    while (cur?.type === "MemberExpression") cur = cur.object;
+    if (cur?.type === "Identifier" && cur.name) acc.add(cur.name);
+  }
+  if (n.type === "UpdateExpression" && n.argument?.type === "Identifier" && n.argument.name) {
+    acc.add(n.argument.name);
+  }
+  for (const key of Object.keys(n)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "range") continue;
+    const child = n[key];
+    if (Array.isArray(child)) child.forEach((c) => collectAssignedIds(c, acc));
+    else if (child && typeof child === "object") collectAssignedIds(child, acc);
+  }
+}
+var FUNCTION_SCOPE_TYPES = /* @__PURE__ */ new Set([
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression",
+  "ObjectMethod",
+  "ClassMethod",
+  "ClassPrivateMethod"
+]);
+var BINDING_SCOPE_TYPES = /* @__PURE__ */ new Set([
+  ...FUNCTION_SCOPE_TYPES,
+  "CatchClause",
+  "ForOfStatement",
+  "ForInStatement"
+]);
+function collectPatternNames(id, acc) {
+  if (!id || typeof id !== "object") return;
+  const n = id;
+  if (n.type === "Identifier" && n.name) acc.add(n.name);
+  else if (n.type === "RestElement") collectPatternNames(n.argument, acc);
+  else if (n.type === "AssignmentPattern") collectPatternNames(n.left, acc);
+  else if (n.type === "ObjectPattern") {
+    for (const p of n.properties ?? []) {
+      const prop = p;
+      if (prop?.type === "RestElement") collectPatternNames(prop.argument, acc);
+      else collectPatternNames(prop?.value, acc);
+    }
+  } else if (n.type === "ArrayPattern") {
+    for (const el of n.elements ?? []) collectPatternNames(el, acc);
+  }
+}
+var freeAssignedCache = /* @__PURE__ */ new WeakMap();
+var mutatorRecvCache = /* @__PURE__ */ new WeakMap();
+function collectFreeAssignedNames(...nodes) {
+  const cachedParts = [];
+  const pending = [];
+  for (const node of nodes) {
+    if (node && typeof node === "object") {
+      const hit = freeAssignedCache.get(node);
+      if (hit) {
+        cachedParts.push(hit);
+        continue;
+      }
+      pending.push(node);
+    }
+  }
+  if (pending.length === 0) {
+    const merged2 = /* @__PURE__ */ new Set();
+    for (const p of cachedParts) for (const n of p) merged2.add(n);
+    return [...merged2];
+  }
+  const free = /* @__PURE__ */ new Set();
+  const markFree = (name, shadowed) => {
+    if (name && name !== "undefined" && !shadowed.has(name)) free.add(name);
+  };
+  const walk = (node, shadowed) => {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    let nextShadowed = shadowed;
+    const pushShadow = (names) => {
+      const add2 = [];
+      for (const name of names) {
+        if (name && !nextShadowed.has(name)) add2.push(name);
+      }
+      if (add2.length === 0) return;
+      nextShadowed = new Set(nextShadowed);
+      for (const name of add2) nextShadowed.add(name);
+    };
+    if (FUNCTION_SCOPE_TYPES.has(n.type)) {
+      const bound = /* @__PURE__ */ new Set();
+      collectPatternNames(n.id, bound);
+      for (const p of n.params ?? []) collectPatternNames(p, bound);
+      pushShadow(bound);
+    } else if (n.type === "CatchClause") {
+      const bound = /* @__PURE__ */ new Set();
+      collectPatternNames(n.param, bound);
+      pushShadow(bound);
+    } else if (n.type === "ForOfStatement" || n.type === "ForInStatement") {
+      const bound = /* @__PURE__ */ new Set();
+      const left = n.left;
+      if (left?.type === "VariableDeclaration") {
+        for (const d of left.declarations ?? []) collectPatternNames(d.id, bound);
+      } else {
+        collectPatternNames(left, bound);
+      }
+      pushShadow(bound);
+    }
+    if (n.type === "AssignmentExpression") {
+      const left = n.left;
+      if (left?.type === "Identifier") markFree(left.name, nextShadowed);
+      else if (left?.type === "MemberExpression") {
+        let cur = left;
+        while (cur?.type === "MemberExpression") {
+          cur = cur.object;
+        }
+        if (cur?.type === "Identifier") markFree(cur.name, nextShadowed);
+      }
+    }
+    if (n.type === "UpdateExpression") {
+      const arg = n.argument;
+      if (arg?.type === "Identifier") markFree(arg.name, nextShadowed);
+    }
+    if (n.type === "CallExpression" && n.callee?.type === "MemberExpression" && n.callee.computed !== true && n.callee.property?.type === "Identifier" && ARR_MUTATOR_NAMES.has(n.callee.property.name)) {
+      const obj2 = n.callee.object;
+      if (obj2?.type === "Identifier") markFree(obj2.name, nextShadowed);
+      else if (obj2?.type === "MemberExpression" || obj2?.type === "ThisExpression") {
+        let cur = obj2;
+        while (cur?.type === "MemberExpression") {
+          cur = cur.object;
+        }
+        if (cur?.type === "Identifier") markFree(cur.name, nextShadowed);
+      }
+    }
+    for (const key of Object.keys(n)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "range") continue;
+      if (key === "callee" || key === "property" || key === "param" || key === "params") continue;
+      const child = n[key];
+      if (Array.isArray(child)) {
+        if (n.type === "BlockStatement" || n.type === "Program" || n.type === "StaticBlock" || n.type === "SwitchCase") {
+          let blockShadow = nextShadowed;
+          for (const stmt of child) {
+            walk(stmt, blockShadow);
+            const stmtNode = stmt;
+            if (!stmtNode) continue;
+            const declared = /* @__PURE__ */ new Set();
+            if (stmtNode.type === "VariableDeclaration") {
+              for (const d of stmtNode.declarations ?? []) collectPatternNames(d.id, declared);
+            } else if (stmtNode.type === "FunctionDeclaration" || stmtNode.type === "ClassDeclaration") {
+              collectPatternNames(stmtNode.id, declared);
+            }
+            if (declared.size > 0) {
+              if (blockShadow === nextShadowed) blockShadow = new Set(blockShadow);
+              for (const name of declared) blockShadow.add(name);
+            }
+          }
+          continue;
+        }
+        for (const item of child) walk(item, nextShadowed);
+      } else if (child && typeof child === "object") {
+        walk(child, nextShadowed);
+      }
+    }
+    if (FUNCTION_SCOPE_TYPES.has(n.type) && n.body) {
+      walk(n.body, nextShadowed);
+    }
+  };
+  for (const node of pending) {
+    walk(node, /* @__PURE__ */ new Set());
+  }
+  const computed = [...free];
+  for (const node of pending) freeAssignedCache.set(node, computed);
+  const merged = new Set(computed);
+  for (const p of cachedParts) for (const n of p) merged.add(n);
+  return [...merged];
+}
+function collectForkBindingNames(...nodes) {
+  return collectFreeAssignedNames(...nodes);
+}
+function stmtCompletesControl(stmt) {
+  if (!stmt) return false;
+  switch (stmt.type) {
+    case "BreakStatement":
+    case "ReturnStatement":
+    case "ThrowStatement":
+    case "ContinueStatement":
+      return true;
+    case "BlockStatement":
+      return stmtCompletesControl(stmt.body[stmt.body.length - 1]);
+    case "IfStatement":
+      return stmt.alternate != null && stmtCompletesControl(stmt.consequent) && stmtCompletesControl(stmt.alternate);
+    default:
+      return false;
+  }
+}
 function stmtReturns(stmt) {
   if (stmt.type === "ReturnStatement" || stmt.type === "ThrowStatement") return true;
   if (stmt.type === "BlockStatement") return stmt.body.some(stmtReturns);
   if (stmt.type === "IfStatement") {
     return stmtReturns(stmt.consequent) && stmt.alternate != null && stmtReturns(stmt.alternate);
   }
+  if (stmt.type === "SwitchStatement") {
+    const arms = [];
+    for (const c of stmt.cases) {
+      const testIsDefault = c.test === null || c.test === void 0;
+      const last = arms[arms.length - 1];
+      if (last && !last.isDefault && last.stmts.length === 0 && !testIsDefault) {
+        last.stmts = c.consequent;
+        continue;
+      }
+      if (last && !last.isDefault && !testIsDefault && last.stmts.length > 0 && c.consequent.length === 0) {
+        continue;
+      }
+      arms.push({ stmts: c.consequent, isDefault: testIsDefault });
+    }
+    const armOk = (a) => a.stmts.length > 0 && a.stmts.every(stmtReturns);
+    const nonDefault = arms.filter((a) => !a.isDefault);
+    const dflt = arms.find((a) => a.isDefault);
+    if (dflt === void 0) return false;
+    return nonDefault.length > 0 && nonDefault.every(armOk) && armOk(dflt);
+  }
   return false;
 }
 function transpileFnBodyStmts(stmts, depth, opts) {
@@ -5957,11 +7943,61 @@ function transpileFnBodyStmts(stmts, depth, opts) {
     if (rest.length === 0) continue;
     const head = stmts.slice(0, i).map((s) => transpileStatement(s, depth, opts)).join("\n");
     const test = transpileExpression(stmt.test, opts);
-    const cons = transpileBlockAsThunk(stmt.consequent, depth, opts);
-    const altBody = transpileFnBodyStmts(rest, depth + 1, opts);
-    const promoted = `${indent(depth)}return $fork(${test}, ${cons}, () => {
+    const recvSet = /* @__PURE__ */ new Set([
+      ...collectForkBindingNames(stmt.consequent),
+      ...collectForkBindingNames(stmt.test),
+      ...rest.flatMap((r) => collectForkBindingNames(r))
+    ]);
+    const names = [...recvSet];
+    const pad = indent(depth);
+    const padIn = indent(depth + 1);
+    const wrapArm = (thunk, outPrefix) => {
+      if (names.length === 0) return thunk;
+      return [
+        `() => {`,
+        ...names.map((n) => `${padIn}${n} = __fk0_${n};`),
+        `${padIn}let __cont = true;`,
+        `${padIn}try {`,
+        `${padIn}  return (${thunk})();`,
+        `${padIn}} catch (e) {`,
+        `${padIn}  if ($isForkExit(e)) __cont = false;`,
+        `${padIn}  throw e;`,
+        `${padIn}} finally {`,
+        `${padIn}  if (__cont) {`,
+        ...names.map((n) => `${padIn}    __${outPrefix}${n} = ${n};`),
+        ...names.map((n) => `${padIn}    __${outPrefix}set_${n} = true;`),
+        `${padIn}  }`,
+        `${padIn}}`,
+        `}`
+      ].join("\n");
+    };
+    const testRecvs = collectArrMutatorReceivers(stmt.test);
+    const testRebinds = testRecvs.size ? emitArrMutatorRebinds(stmt.test, opts, pad) : [];
+    const cons = wrapArm(transpileBlockAsThunk(stmt.consequent, depth, opts), "fk1_");
+    const altBody = transpileFnBodyStmts(rest, depth + 1, { ...opts, inLoop: opts.inLoop });
+    const altThunk = `() => {
 ${altBody}
-${indent(depth)}});`;
+${pad}}`;
+    const alt = wrapArm(altThunk, "fk2_");
+    const inCtrl = (opts.inLoop ?? 0) > 0 || (opts.inTry ?? 0) > 0;
+    const applyJoin = names.length ? forkJoinBindings(names, pad).join("\n") : "";
+    if (names.length === 0) {
+      const promoted2 = [
+        ...testRebinds,
+        inCtrl ? `${pad}$loopReturn($fork(${test}, ${cons}, ${alt}));` : `${pad}return $fork(${test}, ${cons}, ${alt});`
+      ].join("\n");
+      return head ? `${head}
+${promoted2}` : promoted2;
+    }
+    const promoted = [
+      `${pad}{`,
+      ...testRebinds,
+      ...forkBindingDecls(names, padIn),
+      `${padIn}const __fkR = $fork(${test}, ${cons}, ${alt});`,
+      applyJoin.split("\n").map((l) => l.replace(/^\s*/, padIn)).join("\n"),
+      inCtrl ? `${padIn}$loopReturn(__fkR);` : `${padIn}return __fkR;`,
+      `${pad}}`
+    ].join("\n");
     return head ? `${head}
 ${promoted}` : promoted;
   }
@@ -5973,11 +8009,18 @@ function emitDestructure(pattern, fromSrc, kw, pad, opts, out, tmpSeq) {
     return;
   }
   if (pattern.type === "ObjectPattern") {
+    const namedKeys = [];
+    let restName;
     for (const prop of pattern.properties) {
+      if (prop.type === "RestElement") {
+        if (prop.argument.type === "Identifier") restName = prop.argument.name;
+        continue;
+      }
       if (prop.type !== "ObjectProperty") continue;
       if (prop.key.type !== "Identifier" && prop.key.type !== "StringLiteral") continue;
       const key = prop.key.type === "Identifier" ? prop.key.name : String(prop.key.value);
       const keyLit = JSON.stringify(key);
+      namedKeys.push(key);
       if (prop.value.type === "AssignmentPattern") {
         const def = transpileExpression(prop.value.right, opts);
         const left = prop.value.left;
@@ -6002,11 +8045,25 @@ function emitDestructure(pattern, fromSrc, kw, pad, opts, out, tmpSeq) {
         out.push(`${pad}${kw} ${prop.value.name} = $get(${fromSrc}, ${keyLit});`);
       }
     }
+    if (restName) {
+      out.push(
+        `${pad}${kw} ${restName} = $objRest(${fromSrc}, ${JSON.stringify(namedKeys)});`
+      );
+    }
     return;
   }
   if (pattern.type === "ArrayPattern") {
+    let restName;
+    let restAt = 0;
     pattern.elements.forEach((el, i) => {
       if (!el) return;
+      if (el.type === "RestElement") {
+        if (el.argument.type === "Identifier") {
+          restName = el.argument.name;
+          restAt = i;
+        }
+        return;
+      }
       if (el.type === "AssignmentPattern") {
         const def = transpileExpression(el.right, opts);
         const idx = `$idx(${fromSrc}, $lit(${i}))`;
@@ -6029,6 +8086,9 @@ function emitDestructure(pattern, fromSrc, kw, pad, opts, out, tmpSeq) {
         out.push(`${pad}${kw} ${el.name} = $idx(${fromSrc}, $lit(${i}));`);
       }
     });
+    if (restName) {
+      out.push(`${pad}${kw} ${restName} = $arrRest(${fromSrc}, ${restAt});`);
+    }
   }
 }
 function emitParamBinding(params, pad, opts) {
@@ -6069,6 +8129,122 @@ function emitParamBinding(params, pad, opts) {
   });
   return { sig, rest, prologue };
 }
+function collectArrMutatorReceivers(node, acc = /* @__PURE__ */ new Set()) {
+  if (!node || typeof node !== "object") return acc;
+  const hit = mutatorRecvCache.get(node);
+  if (hit) {
+    for (const n of hit) acc.add(n);
+    return acc;
+  }
+  const local = /* @__PURE__ */ new Set();
+  collectArrMutatorReceiversUncached(node, local);
+  mutatorRecvCache.set(node, local);
+  for (const n of local) acc.add(n);
+  return acc;
+}
+function collectArrMutatorReceiversUncached(node, acc = /* @__PURE__ */ new Set()) {
+  if (!node || typeof node !== "object") return acc;
+  const n = node;
+  if (n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression" || n.type === "ObjectMethod" || n.type === "ClassMethod" || n.type === "FunctionDeclaration") {
+    return acc;
+  }
+  if (n.type === "CallExpression" && n.callee?.type === "MemberExpression") {
+    const callee = n.callee;
+    const propName = !callee.computed && callee.property?.type === "Identifier" ? callee.property.name : void 0;
+    if (propName && ARR_MUTATOR_NAMES.has(propName)) {
+      const obj2 = callee.object;
+      if (obj2?.type === "Identifier") {
+        acc.add(obj2.name);
+      } else if (obj2?.type === "MemberExpression") {
+        let cur = obj2;
+        while (cur?.type === "MemberExpression") {
+          cur = cur.object;
+        }
+        if (cur?.type === "Identifier") {
+          acc.add(cur.name);
+        }
+      }
+    }
+  }
+  for (const key of Object.keys(n)) {
+    if (key === "loc" || key === "start" || key === "end" || key === "range") continue;
+    const child = n[key];
+    if (Array.isArray(child)) child.forEach((c) => collectArrMutatorReceiversUncached(c, acc));
+    else if (child && typeof child === "object") collectArrMutatorReceiversUncached(child, acc);
+  }
+  return acc;
+}
+function forkArmThunk(bodyLines, outPrefix, names) {
+  return [
+    `() => {`,
+    ...names.map((n) => `  ${n} = __fk0_${n};`),
+    `  let __cont = true;`,
+    `  try {`,
+    ...bodyLines.map((l) => `    ${l}`),
+    `  } catch (e) {`,
+    `    if ($isForkExit(e)) __cont = false;`,
+    `    throw e;`,
+    `  } finally {`,
+    `    if (__cont) {`,
+    ...names.map((n) => `      __${outPrefix}${n} = ${n};`),
+    ...names.map((n) => `      __${outPrefix}set_${n} = true;`),
+    `    }`,
+    `  }`,
+    `}`
+  ].join("\n");
+}
+function forkBindingDecls(names, pad = "") {
+  return names.flatMap((n) => [
+    `${pad}const __fk0_${n} = ${n};`,
+    `${pad}let __fk1_${n}; let __fk2_${n};`,
+    `${pad}let __fk1_set_${n} = false; let __fk2_set_${n} = false;`
+  ]);
+}
+function forkJoinBindings(names, pad = "") {
+  return names.map(
+    (n) => `${pad}${n} = (__fk1_set_${n} && __fk2_set_${n}) ? $join(__fk1_${n}, __fk2_${n}) : (__fk1_set_${n} ? __fk1_${n} : (__fk2_set_${n} ? __fk2_${n} : ${n}));`
+  );
+}
+function transpileShortCircuitExpr(opts, parts) {
+  const alwaysNames = new Set(collectForkBindingNames(...parts.alwaysNodes));
+  const branchNames = new Set(alwaysNames);
+  for (const n of parts.consNodes) for (const id of collectForkBindingNames(n)) branchNames.add(id);
+  for (const n of parts.altNodes) for (const id of collectForkBindingNames(n)) branchNames.add(id);
+  const names = [...branchNames];
+  const alwaysRebinds = [];
+  for (const n of parts.alwaysNodes) {
+    alwaysRebinds.push(...emitArrMutatorRebinds(n, opts, ""));
+  }
+  const consRebinds = [];
+  for (const n of parts.consNodes) {
+    if (parts.alwaysNodes.includes(n)) continue;
+    consRebinds.push(...emitArrMutatorRebinds(n, opts, ""));
+  }
+  const altRebinds = [];
+  for (const n of parts.altNodes) {
+    if (parts.alwaysNodes.includes(n)) continue;
+    altRebinds.push(...emitArrMutatorRebinds(n, opts, ""));
+  }
+  if (alwaysNames.size === 0 && branchNames.size === 0) {
+    const forkTest2 = parts.testSrc ?? parts.alwaysSrc;
+    const consExpr = parts.consSrc === "__test" ? parts.alwaysSrc : parts.consSrc;
+    const altExpr = parts.altSrc === "__test" ? parts.alwaysSrc : parts.altSrc;
+    return `$fork(${forkTest2}, () => ${consExpr}, () => ${altExpr})`;
+  }
+  const consLines = parts.consSrc === "__test" ? [`return __test;`] : consRebinds.length === 0 ? [`return (${parts.consSrc});`] : [`const __v = (${parts.consSrc});`, ...consRebinds, `return __v;`];
+  const altLines = parts.altSrc === "__test" ? [`return __test;`] : altRebinds.length === 0 ? [`return (${parts.altSrc});`] : [`const __v = (${parts.altSrc});`, ...altRebinds, `return __v;`];
+  const forkTest = parts.testSrc ?? "__test";
+  return [
+    `(() => {`,
+    `  const __test = (${parts.alwaysSrc});`,
+    ...alwaysRebinds.map((l) => `  ${l}`),
+    ...names.length ? forkBindingDecls(names, "  ") : [],
+    `  const __r = $fork(${forkTest}, ${forkArmThunk(consLines, "fk1_", names)}, ${forkArmThunk(altLines, "fk2_", names)});`,
+    ...forkJoinBindings(names, "  "),
+    `  return __r;`,
+    `})()`
+  ].join("\n");
+}
 function transpileStatement(stmt, depth, opts) {
   const pad = indent(depth);
   switch (stmt.type) {
@@ -6106,20 +8282,22 @@ function transpileStatement(stmt, depth, opts) {
     }
     case "FunctionDeclaration": {
       if (!stmt.id) return `${pad}// <anonymous fn skipped>`;
+      const exportKw = depth === 0 ? "export " : "";
+      const fnOpts = { ...opts, inLoop: 0 };
       const { sig, rest, prologue } = emitParamBinding(
         stmt.params,
         indent(depth + 2),
-        opts
+        fnOpts
       );
       const named = sig;
       const paramsSig = rest ? [...named, `...${rest}`] : named;
       const params = paramsSig.join(", ");
-      const bodyStmts = stmt.body.type === "BlockStatement" ? [...prologue, transpileFnBodyStmts(stmt.body.body, depth + 2, opts)].join("\n") : `${indent(depth + 2)}return ${transpileExpression(stmt.body, opts)};`;
+      const bodyStmts = stmt.body.type === "BlockStatement" ? [...prologue, transpileFnBodyStmts(stmt.body.body, depth + 2, fnOpts)].join("\n") : `${indent(depth + 2)}return ${transpileExpression(stmt.body, fnOpts)};`;
       const restBind = rest ? `${indent(depth + 1)}const ${rest} = arguments.length > ${named.length} ? $arr(Array.from(arguments).slice(${named.length})) : $arr([]);
 ` : "";
       if (stmt.generator) {
         return [
-          `${pad}export function ${stmt.id.name}(${named.join(", ")}) {`,
+          `${pad}${exportKw}function ${stmt.id.name}(${named.join(", ")}) {`,
           restBind,
           `${indent(depth + 1)}return $gen(() => {`,
           bodyStmts,
@@ -6129,7 +8307,7 @@ function transpileStatement(stmt, depth, opts) {
       }
       if (stmt.async) {
         return [
-          `${pad}export function ${stmt.id.name}(${named.join(", ")}) {`,
+          `${pad}${exportKw}function ${stmt.id.name}(${named.join(", ")}) {`,
           restBind,
           `${indent(depth + 1)}return $async(() => {`,
           bodyStmts,
@@ -6138,7 +8316,7 @@ function transpileStatement(stmt, depth, opts) {
         ].join("\n");
       }
       return [
-        `${pad}export function ${stmt.id.name}(${named.join(", ")}) {`,
+        `${pad}${exportKw}function ${stmt.id.name}(${named.join(", ")}) {`,
         restBind,
         bodyStmts,
         `${pad}}`
@@ -6146,16 +8324,73 @@ function transpileStatement(stmt, depth, opts) {
     }
     case "ReturnStatement": {
       const asVar = matchAsOverride(stmt, opts);
-      if (asVar) return `${pad}return ${asVar};`;
-      if (!stmt.argument) return `${pad}return $lit(undefined);`;
-      return `${pad}return ${transpileExpression(stmt.argument, opts)};`;
+      const prefix = (opts.inLoop ?? 0) > 0 ? "$loopReturn" : "return";
+      const markExpr = opts.tryMarkName ?? "$tryCurrentMark()";
+      const emitRet = (src, mutNodes) => {
+        const retRebinds = mutNodes ? emitArrMutatorRebinds(mutNodes, opts, pad) : [];
+        if ((opts.inTry ?? 0) > 0) {
+          return [
+            `${pad}const __nudoRet = ${src};`,
+            ...retRebinds,
+            `${pad}{`,
+            `${indent(depth + 1)}const __xs = $tryTakeSince(${markExpr});`,
+            `${indent(depth + 1)}if (__xs.length) {`,
+            `${indent(depth + 2)}$pushLoopExit(__nudoRet);`,
+            `${indent(depth + 2)}$throw(__xs.reduce((a, b) => $join(a, b)));`,
+            `${indent(depth + 1)}}`,
+            `${pad}}`,
+            `${pad}${prefix}(__nudoRet);`
+          ].join("\n");
+        }
+        if (retRebinds.length === 0) return `${pad}${prefix}(${src});`;
+        return [
+          `${pad}let __mutRet = ${src};`,
+          ...retRebinds,
+          `${pad}${prefix}(__mutRet);`
+        ].join("\n");
+      };
+      if (asVar) return emitRet(asVar);
+      if (!stmt.argument) return emitRet(`$lit(undefined)`);
+      const retSrc = transpileExpression(stmt.argument, opts);
+      return emitRet(retSrc, stmt.argument);
     }
     case "ThrowStatement": {
       const arg = stmt.argument ? transpileExpression(stmt.argument, opts) : "$lit(undefined)";
       return `${pad}$throw(${arg});`;
     }
-    case "ExpressionStatement":
+    case "ExpressionStatement": {
+      const expr = stmt.expression;
+      const exprRebinds = emitArrMutatorRebinds(expr, opts, pad);
+      if (expr.type === "CallExpression" && expr.callee.type === "MemberExpression" && !expr.callee.computed && expr.callee.property.type === "Identifier") {
+        const methodName = expr.callee.property.name;
+        if (["push", "unshift", "splice", "pop", "shift", "reverse", "sort"].includes(methodName)) {
+          const argSrcs = expr.arguments.map(
+            (a) => a.type === "SpreadElement" ? "$lit(undefined)" : transpileExpression(a, opts)
+          ).join(", ");
+          const objNode = expr.callee.object;
+          if (objNode.type === "Identifier") {
+            const name = objNode.name;
+            return `${pad}${name} = $arrMutContainer(${name}, ${JSON.stringify(methodName)}, [${argSrcs}]);`;
+          }
+          if (objNode.type === "MemberExpression" || objNode.type === "ThisExpression") {
+            const path = objNode.type === "MemberExpression" ? memberPathOf(objNode, opts) : null;
+            if (path) {
+              const recvSrc = readPathSrc(path);
+              const mutSrc = `$arrMutContainer(${recvSrc}, ${JSON.stringify(methodName)}, [${argSrcs}])`;
+              return `${pad}${path.rootSrc} = ${setPathSrc(path, mutSrc)};`;
+            }
+            return `${pad}${transpileExpression(stmt.expression, opts)};`;
+          }
+        }
+      }
+      if (exprRebinds.length > 0) {
+        return [
+          `${pad}${transpileExpression(expr, opts)};`,
+          ...exprRebinds
+        ].join("\n");
+      }
       return `${pad}${transpileExpression(stmt.expression, opts)};`;
+    }
     case "VariableDeclaration": {
       const kw = "let";
       const asVar = matchAsOverride(stmt, opts);
@@ -6165,6 +8400,9 @@ function transpileStatement(stmt, depth, opts) {
         if (d.id.type === "Identifier") {
           const init = asVar ? asVar : d.init ? transpileExpression(d.init, opts) : "$lit(undefined)";
           lines.push(`${pad}${kw} ${d.id.name} = ${init};`);
+          if (d.init && !asVar) {
+            lines.push(...emitArrMutatorRebinds(d.init, opts, pad));
+          }
           continue;
         }
         if (!d.init) {
@@ -6174,18 +8412,74 @@ function transpileStatement(stmt, depth, opts) {
         const initSrc = transpileExpression(d.init, opts);
         const tmp = `_d${tmpSeq++}_${stmt.loc?.start.line ?? 0}`;
         lines.push(`${pad}const ${tmp} = ${initSrc};`);
+        lines.push(...emitArrMutatorRebinds(d.init, opts, pad));
         emitDestructure(d.id, tmp, kw, pad, opts, lines, { n: 0 });
       }
       return lines.join("\n");
     }
     case "IfStatement": {
       const test = transpileExpression(stmt.test, opts);
-      const cons = transpileBlockAsThunk(stmt.consequent, depth, opts);
-      const alt = stmt.alternate ? transpileBlockAsThunk(stmt.alternate, depth, opts) : "undefined";
+      const recvSet = /* @__PURE__ */ new Set([
+        ...collectForkBindingNames(stmt.consequent),
+        ...collectForkBindingNames(stmt.alternate)
+      ]);
+      const testRecvs = collectArrMutatorReceivers(stmt.test);
+      const testRebinds = testRecvs.size ? emitArrMutatorRebinds(stmt.test, opts, pad) : [];
+      const names = [...recvSet];
+      const padIn = indent(depth + 1);
+      const padDecl = names.length > 0 ? padIn : pad;
+      const wrapArm = (thunk, outPrefix) => {
+        if (names.length === 0) return thunk;
+        return [
+          `() => {`,
+          ...names.map((n) => `${padIn}${n} = __fk0_${n};`),
+          `${padIn}let __cont = true;`,
+          `${padIn}try {`,
+          `${padIn}  return (${thunk})();`,
+          `${padIn}} catch (e) {`,
+          `${padIn}  if ($isForkExit(e)) __cont = false;`,
+          `${padIn}  throw e;`,
+          `${padIn}} finally {`,
+          `${padIn}  if (__cont) {`,
+          ...names.map((n) => `${padIn}    __${outPrefix}${n} = ${n};`),
+          ...names.map((n) => `${padIn}    __${outPrefix}set_${n} = true;`),
+          `${padIn}  }`,
+          `${padIn}}`,
+          `}`
+        ].join("\n");
+      };
+      const consRaw = transpileBlockAsThunk(stmt.consequent, depth, opts);
+      const altRaw = stmt.alternate ? transpileBlockAsThunk(stmt.alternate, depth, opts) : "undefined";
+      const cons = wrapArm(consRaw, "fk1_");
+      const alt = names.length ? wrapArm(altRaw === "undefined" ? "() => $lit(undefined)" : altRaw, "fk2_") : altRaw;
+      const joinLines = names.length ? [...testRebinds, ...forkBindingDecls(names, padDecl)] : testRebinds;
+      const applyJoin = names.length ? forkJoinBindings(names, padDecl).join("\n") : "";
+      const inCtrl = (opts.inLoop ?? 0) > 0;
+      const openBlock = names.length > 0 ? `${pad}{` : null;
+      const closeBlock = names.length > 0 ? `${pad}}` : null;
       if (stmtReturns(stmt.consequent) && stmt.alternate !== void 0 && stmt.alternate !== null && stmtReturns(stmt.alternate)) {
-        return `${pad}return $fork(${test}, ${cons}, ${alt});`;
+        if (names.length === 0) {
+          return [
+            ...joinLines,
+            inCtrl ? `${pad}$loopReturn($fork(${test}, ${cons}, ${alt}));` : `${pad}return $fork(${test}, ${cons}, ${alt});`
+          ].join("\n");
+        }
+        return [
+          openBlock,
+          ...joinLines,
+          `${padDecl}const __fkR = $fork(${test}, ${cons}, ${alt});`,
+          applyJoin,
+          inCtrl ? `${padDecl}$loopReturn(__fkR);` : `${padDecl}return __fkR;`,
+          closeBlock
+        ].join("\n");
       }
-      return `${pad}$fork(${test}, ${cons}, ${alt});`;
+      return [
+        openBlock,
+        ...joinLines,
+        `${padDecl}$fork(${test}, ${cons}, ${alt});`,
+        applyJoin,
+        closeBlock
+      ].filter((l) => l !== null && l !== "").join("\n");
     }
     case "ForStatement": {
       const initName = extractForInitName(stmt.init);
@@ -6193,8 +8487,21 @@ function transpileStatement(stmt, depth, opts) {
       const initExpr = stmt.init && stmt.init.type === "VariableDeclaration" && stmt.init.declarations[0]?.init ? transpileExpression(stmt.init.declarations[0].init, opts) : "$lit(undefined)";
       const testSrc = stmt.test ? transpileExpression(stmt.test, opts) : "$lit(true)";
       const updateSrc = stmt.update ? transpileExpression(stmt.update, opts) : `$lit(undefined)`;
-      const bodyStmts = stmt.body.type === "BlockStatement" ? stmt.body.body.map((s) => transpileStatement(s, depth + 2, opts)).join("\n") : transpileStatement(stmt.body, depth + 2, opts);
+      const forBodyOpts = {
+        ...opts,
+        inLoop: (opts.inLoop ?? 0) + 1
+      };
+      const bodyStmts = stmt.body.type === "BlockStatement" ? stmt.body.body.map((s) => transpileStatement(s, depth + 2, forBodyOpts)).join("\n") : transpileStatement(stmt.body, depth + 2, forBodyOpts);
       const max = opts.maxLoopIters ?? 8;
+      const assigned = /* @__PURE__ */ new Set();
+      collectAssignedIds(stmt.body, assigned);
+      collectAssignedIds(stmt.test, assigned);
+      collectAssignedIds(stmt.update, assigned);
+      collectArrMutatorReceivers(stmt.body, assigned);
+      const names = [...assigned].filter((n) => n !== initName && n !== "undefined");
+      const packSrc = names.length === 0 ? null : `$obj({ ${names.map((n) => `${JSON.stringify(n)}: ${n}`).join(", ")} })`;
+      const unpackSrc = names.length === 0 ? null : `(__lp) => { ${names.map((n) => `${n} = $get(__lp, ${JSON.stringify(n)});`).join(" ")} }`;
+      const optsSrc = packSrc && unpackSrc ? `, { pack: () => ${packSrc}, unpack: ${unpackSrc} }` : "";
       return [
         `${pad}// for \u2192 $for (bounded unroll, max=${max})`,
         `${pad}$for(`,
@@ -6205,7 +8512,7 @@ function transpileStatement(stmt, depth, opts) {
         bodyStmts,
         `${indent(depth + 1)}  return ${initName};`,
         `${indent(depth + 1)}},`,
-        `${indent(depth + 1)}${max}`,
+        `${indent(depth + 1)}${max}${optsSrc}`,
         `${pad});`
       ].join("\n");
     }
@@ -6213,58 +8520,172 @@ function transpileStatement(stmt, depth, opts) {
       return transpileFnBodyStmts(stmt.body, depth, opts);
     case "SwitchStatement": {
       const disc = transpileExpression(stmt.discriminant, opts);
-      const arms = [];
+      const pre = [];
+      let pendingTests = [];
       for (const c of stmt.cases) {
         const testSrc = c.test ? transpileExpression(c.test, opts) : null;
         if (testSrc === null) {
-          arms.push({ tests: [], stmts: c.consequent, isDefault: true });
-        } else if (arms.length > 0 && !arms[arms.length - 1].isDefault && arms[arms.length - 1].stmts.length === 0) {
-          const last = arms[arms.length - 1];
-          last.tests.push(testSrc);
-          last.stmts = c.consequent;
-        } else {
-          arms.push({ tests: [testSrc], stmts: c.consequent, isDefault: false });
+          if (pendingTests.length > 0 && c.consequent.length > 0) {
+            pre.push({ tests: pendingTests, stmts: c.consequent, isDefault: false });
+            pendingTests = [];
+          }
+          pre.push({ tests: [], stmts: c.consequent, isDefault: true });
+          continue;
         }
-      }
-      const merged = [];
-      for (const arm of arms) {
-        if (merged.length > 0 && merged[merged.length - 1].stmts === arm.stmts && !arm.isDefault) {
-          merged[merged.length - 1].tests.push(...arm.tests);
-        } else {
-          merged.push({ ...arm, tests: [...arm.tests] });
+        if (c.consequent.length === 0) {
+          pendingTests.push(testSrc);
+          continue;
         }
+        pre.push({ tests: [...pendingTests, testSrc], stmts: c.consequent, isDefault: false });
+        pendingTests = [];
+      }
+      if (pendingTests.length > 0) {
+        pre.push({ tests: pendingTests, stmts: [], isDefault: false });
+      }
+      const merged = pre.map((arm) => ({ ...arm, tests: [...arm.tests], stmts: [...arm.stmts] }));
+      for (let i = 0; i < merged.length; i++) {
+        const arm = merged[i];
+        const body = [...arm.stmts];
+        let j = i + 1;
+        while (j < merged.length && !stmtCompletesControl(body[body.length - 1])) {
+          body.push(...merged[j].stmts);
+          if (stmtCompletesControl(body[body.length - 1])) break;
+          j++;
+        }
+        arm.stmts = body;
       }
+      const armReturns = (arm) => arm.stmts.length > 0 && arm.stmts.every(stmtReturns);
+      const nonDefaultArms = merged.filter((a) => !a.isDefault);
+      const defaultArm = merged.find((a) => a.isDefault);
+      const allReturn = defaultArm !== void 0 && nonDefaultArms.length > 0 && nonDefaultArms.every(armReturns) && armReturns(defaultArm);
       const caseLines = [];
+      const sharedBodyDecls = [];
       let defaultSrc = null;
+      const bodyIdxBase = switchBodySeq;
+      let bodyIdx = 0;
+      const armOpts = {
+        ...opts,
+        inLoop: (opts.inLoop ?? 0) + 1
+      };
+      const recvSet = /* @__PURE__ */ new Set([
+        ...merged.flatMap((a) => collectForkBindingNames(...a.stmts)),
+        ...collectForkBindingNames(stmt.discriminant)
+      ]);
+      const names = [...recvSet];
+      const nArms = merged.filter((a) => !a.isDefault).length + (defaultArm ? 1 : 0) + (defaultArm ? 0 : 1);
+      const wrapArmThunk = (thunk, outIdx) => {
+        if (names.length === 0) return thunk;
+        return [
+          `() => {`,
+          ...names.map((n) => `${indent(depth + 1)}${n} = __sw0_${n};`),
+          `${indent(depth + 1)}let __cont = true;`,
+          `${indent(depth + 1)}try {`,
+          `${indent(depth + 2)}return (${thunk})();`,
+          `${indent(depth + 1)}} catch (e) {`,
+          `${indent(depth + 2)}if ($isForkExit(e)) __cont = false;`,
+          `${indent(depth + 2)}throw e;`,
+          `${indent(depth + 1)}} finally {`,
+          `${indent(depth + 2)}if (__cont) {`,
+          ...names.map((n) => `${indent(depth + 3)}__sw${outIdx + 1}_${n} = ${n};`),
+          ...names.map((n) => `${indent(depth + 3)}__sw${outIdx + 1}set_${n} = true;`),
+          `${indent(depth + 2)}}`,
+          `${indent(depth + 1)}}`,
+          `}`
+        ].join("\n");
+      };
+      let armSeq = 0;
       for (const arm of merged) {
-        const body = arm.stmts.map((s) => transpileStatement(s, depth + 2, opts)).join("\n") || `${indent(depth + 2)}return $lit(undefined);`;
-        const thunk = `() => {
+        const body = arm.stmts.length === 0 ? "" : arm.stmts.map((s) => transpileStatement(s, depth + 2, armOpts)).join("\n");
+        const rawThunk = `() => {
 ${body}
 ${indent(depth + 1)}}`;
+        const thunk = wrapArmThunk(rawThunk, armSeq);
+        armSeq++;
+        const shared = arm.tests.length > 1 && !arm.isDefault;
+        const runRef = shared ? `__swBody${bodyIdxBase + bodyIdx++}` : thunk;
+        if (shared) {
+          sharedBodyDecls.push(`${pad}const ${runRef} = ${thunk};`);
+        }
         if (arm.isDefault) {
           defaultSrc = thunk;
         } else {
           for (const t of arm.tests) {
-            caseLines.push(`{ test: ${t}, run: ${thunk} },`);
+            caseLines.push(`{ test: ${t}, run: ${runRef} },`);
           }
         }
       }
+      if (!defaultArm && names.length > 0) {
+        defaultSrc = wrapArmThunk(`() => {
+${indent(depth + 2)}return $lit(undefined);
+${indent(depth + 1)}}`, armSeq);
+      }
+      switchBodySeq += Math.max(bodyIdx, 1);
       const dflt = defaultSrc ? `, ${defaultSrc}` : "";
+      const discRebinds = collectArrMutatorReceivers(stmt.discriminant).size ? emitArrMutatorRebinds(stmt.discriminant, opts, pad) : [];
+      const switchCall = `$switch(${disc}, [
+${caseLines.map((l) => indent(depth + 1) + l).join("\n")}
+${indent(depth + 1)}]${dflt})`;
+      if (names.length === 0) {
+        return [
+          ...discRebinds,
+          ...sharedBodyDecls,
+          allReturn ? `${pad}return ${switchCall};` : `${pad}${switchCall};`
+        ].join("\n");
+      }
+      const decls = names.flatMap((n) => [
+        `${pad}const __sw0_${n} = ${n};`,
+        ...Array.from(
+          { length: Math.max(nArms, armSeq + (defaultArm ? 0 : 1)) },
+          (_, i) => `${pad}let __sw${i + 1}_${n}; let __sw${i + 1}set_${n} = false;`
+        )
+      ]);
+      const slotCount = Math.max(nArms, armSeq + (defaultArm ? 0 : 1));
+      const joins = names.map((n) => {
+        const slots = Array.from(
+          { length: slotCount },
+          (_, i) => `(__sw${i + 1}set_${n} ? __sw${i + 1}_${n} : null)`
+        );
+        return `${pad}${n} = (() => { const __p = [${slots.join(",")}].filter((x) => x !== null); return __p.length === 0 ? ${n} : __p.reduce((a, b) => $join(a, b)); })();`;
+      });
       return [
-        `${pad}return $switch(${disc}, [`,
-        ...caseLines.map((l) => indent(depth + 1) + l),
-        `${indent(depth + 1)}]${dflt});`
-      ].join("\n");
+        ...discRebinds,
+        `${pad}{`,
+        ...decls.map((l) => l.replace(new RegExp(`^${pad}`), `${pad}`)),
+        ...sharedBodyDecls.map(
+          (l) => l.startsWith(pad) ? `${pad}${l.slice(pad.length)}` : `${pad}${l}`
+        ),
+        `${pad}const __swR = ${switchCall};`,
+        ...joins,
+        allReturn ? `${pad}return __swR;` : null,
+        `${pad}}`
+      ].filter((l) => l !== null).join("\n");
     }
     case "TryStatement": {
-      const tryBody = stmt.block.type === "BlockStatement" ? stmt.block.body.map((s) => transpileStatement(s, depth + 1, opts)).join("\n") : transpileStatement(stmt.block, depth + 1, opts);
-      const lines = [`${pad}try {`, tryBody, `${pad}}`];
+      const markName = `__nudoTm_${stmt.loc?.start.line ?? 0}`;
+      const tryOpts = {
+        ...opts,
+        inTry: (opts.inTry ?? 0) + 1,
+        tryMarkName: markName
+      };
+      const tryBody = stmt.block.type === "BlockStatement" ? stmt.block.body.map((s) => transpileStatement(s, depth + 1, tryOpts)).join("\n") : transpileStatement(stmt.block, depth + 1, tryOpts);
+      const lines = [
+        `${pad}const ${markName} = $tryMark();`,
+        `${pad}try {`,
+        tryBody,
+        `${pad}}`
+      ];
+      const catchParam = stmt.handler?.param?.type === "Identifier" ? stmt.handler.param.name : "e";
+      const catchTmp = `__nudoE_${stmt.loc?.start.line ?? 0}`;
+      const transpileCatchBody = (d, o) => !stmt.handler ? "" : stmt.handler.body.type === "BlockStatement" ? stmt.handler.body.body.map((s) => transpileStatement(s, d, o)).join("\n") : transpileStatement(stmt.handler.body, d, o);
       if (stmt.handler) {
-        const param = stmt.handler.param?.type === "Identifier" ? stmt.handler.param.name : "e";
-        const catchTmp = `__nudoE_${stmt.loc?.start.line ?? 0}`;
-        const catchBody = stmt.handler.body.type === "BlockStatement" ? stmt.handler.body.body.map((s) => transpileStatement(s, depth + 1, opts)).join("\n") : transpileStatement(stmt.handler.body, depth + 1, opts);
+        const catchBody = transpileCatchBody(depth + 1, opts);
         lines.push(`${pad}catch (${catchTmp}) {`);
-        lines.push(`${indent(depth + 1)}const ${param} = $catchVal(${catchTmp});`);
+        lines.push(`${indent(depth + 1)}$rethrowIfNudoReturn(${catchTmp});`);
+        lines.push(`${indent(depth + 1)}const __xs_${markName} = $tryTakeSince(${markName});`);
+        lines.push(`${indent(depth + 1)}__xs_${markName}.push($catchVal(${catchTmp}));`);
+        lines.push(
+          `${indent(depth + 1)}const ${catchParam} = __xs_${markName}.reduce((a, b) => $join(a, b));`
+        );
         lines.push(catchBody);
         lines.push(`${pad}}`);
       }
@@ -6272,6 +8693,30 @@ ${indent(depth + 1)}}`;
         const finBody = stmt.finalizer.type === "BlockStatement" ? stmt.finalizer.body.map((s) => transpileStatement(s, depth + 1, opts)).join("\n") : transpileStatement(stmt.finalizer, depth + 1, opts);
         lines.push(`${pad}finally {`);
         lines.push(finBody);
+        lines.push(`${pad}$tryPopMark();`);
+        lines.push(`${pad}}`);
+      } else {
+        lines.push(`${pad}$tryPopMark();`);
+      }
+      if (stmt.handler) {
+        const catchBody = transpileCatchBody(depth + 2, opts);
+        lines.push(`${pad}{`);
+        lines.push(`${indent(depth + 1)}const __post_${markName} = $tryTakeSince(${markName});`);
+        lines.push(`${indent(depth + 1)}if (__post_${markName}.length) {`);
+        lines.push(
+          `${indent(depth + 2)}const ${catchParam} = __post_${markName}.reduce((a, b) => $join(a, b));`
+        );
+        lines.push(
+          catchBody.split("\n").map((l) => l ? `${indent(depth + 2)}${l.trimStart()}` : l).join("\n")
+        );
+        lines.push(`${indent(depth + 1)}}`);
+        lines.push(`${pad}}`);
+      } else {
+        lines.push(`${pad}{`);
+        lines.push(`${indent(depth + 1)}const __post_${markName} = $tryTakeSince(${markName});`);
+        lines.push(`${indent(depth + 1)}if (__post_${markName}.length) {`);
+        lines.push(`${indent(depth + 2)}$throw(__post_${markName}.reduce((a, b) => $join(a, b)));`);
+        lines.push(`${indent(depth + 1)}}`);
         lines.push(`${pad}}`);
       }
       return lines.join("\n");
@@ -6300,24 +8745,77 @@ ${indent(depth + 1)}}`;
           { n: 0 }
         );
       }
-      const bodyStmts = stmt.body.type === "BlockStatement" ? stmt.body.body.map((s) => transpileStatement(s, depth + 2, opts)).join("\n") : transpileStatement(stmt.body, depth + 2, opts);
+      const bodyOpts = {
+        ...opts,
+        inLoop: (opts.inLoop ?? 0) + 1
+      };
+      const bodyStmts = stmt.body.type === "BlockStatement" ? stmt.body.body.map((s) => transpileStatement(s, depth + 2, bodyOpts)).join("\n") : transpileStatement(stmt.body, depth + 2, bodyOpts);
       const max = opts.maxLoopIters ?? 8;
+      const assigned = /* @__PURE__ */ new Set();
+      collectAssignedIds(stmt.body, assigned);
+      collectArrMutatorReceivers(stmt.body, assigned);
+      const names = [...assigned].filter((n) => n !== bindName && n !== "undefined");
+      const optsSrc = names.length === 0 ? "" : `, { pack: () => $obj({ ${names.map((n) => `${JSON.stringify(n)}: ${n}`).join(", ")} }), unpack: (__lp) => { ${names.map((n) => `${n} = $get(__lp, ${JSON.stringify(n)});`).join(" ")} } }`;
       return [
         `${pad}$forOf(${iter}, (${bindName}, _i) => {`,
         ...bodyLines,
         bodyStmts,
-        `${pad}}, ${max});`
+        `${pad}}, ${max}${optsSrc});`
       ].join("\n");
     }
     case "WhileStatement": {
       const test = transpileExpression(stmt.test, opts);
-      const body = stmt.body.type === "BlockStatement" ? stmt.body.body.map((s) => transpileStatement(s, depth + 1, opts)).join("\n") : transpileStatement(stmt.body, depth + 1, opts);
+      const bodyOpts = {
+        ...opts,
+        inLoop: (opts.inLoop ?? 0) + 1
+      };
+      const body = stmt.body.type === "BlockStatement" ? stmt.body.body.map((s) => transpileStatement(s, depth + 1, bodyOpts)).join("\n") : transpileStatement(stmt.body, depth + 1, bodyOpts);
       const max = opts.maxLoopIters ?? 8;
+      const assigned = /* @__PURE__ */ new Set();
+      collectAssignedIds(stmt.body, assigned);
+      collectAssignedIds(stmt.test, assigned);
+      const names = [...assigned].filter((n) => n !== "undefined");
+      if (names.length === 0) {
+        return [
+          `${pad}// while \u2192 $whileSeq (bounded, max=${max})`,
+          `${pad}$whileSeq(() => ${test}, () => {`,
+          body,
+          `${pad}}, ${max});`
+        ].join("\n");
+      }
+      const packSrc = `$obj({ ${names.map((n) => `${JSON.stringify(n)}: ${n}`).join(", ")} })`;
+      const unpackSrc = `(__lp) => { ${names.map((n) => `${n} = $get(__lp, ${JSON.stringify(n)});`).join(" ")} }`;
       return [
-        `${pad}// while \u2192 $whileSeq (bounded, max=${max})`,
+        `${pad}// while \u2192 $whileSeq (instrumented bindings: ${names.join(", ")})`,
         `${pad}$whileSeq(() => ${test}, () => {`,
         body,
-        `${pad}}, ${max});`
+        `${pad}}, ${max}, { pack: () => ${packSrc}, unpack: ${unpackSrc} });`
+      ].join("\n");
+    }
+    case "DoWhileStatement": {
+      const test = transpileExpression(stmt.test, opts);
+      const bodyOpts = {
+        ...opts,
+        inLoop: (opts.inLoop ?? 0) + 1
+      };
+      const bodyStmts = stmt.body.type === "BlockStatement" ? stmt.body.body.map((s) => transpileStatement(s, depth + 1, bodyOpts)).join("\n") : transpileStatement(stmt.body, depth + 1, bodyOpts);
+      const max = opts.maxLoopIters ?? 8;
+      const assigned = /* @__PURE__ */ new Set();
+      collectAssignedIds(stmt.body, assigned);
+      collectAssignedIds(stmt.test, assigned);
+      collectArrMutatorReceivers(stmt.body, assigned);
+      const names = [...assigned].filter((n) => n !== "undefined");
+      const packSrc = names.length === 0 ? null : `$obj({ ${names.map((n) => `${JSON.stringify(n)}: ${n}`).join(", ")} })`;
+      const unpackSrc = names.length === 0 ? null : `(__lp) => { ${names.map((n) => `${n} = $get(__lp, ${JSON.stringify(n)});`).join(" ")} }`;
+      const optsSrc = packSrc && unpackSrc ? `, { pack: () => ${packSrc}, unpack: ${unpackSrc} }` : "";
+      return [
+        `${pad}// do-while \u2192 body + $whileSeq (bounded, max=${max})`,
+        `{`,
+        bodyStmts,
+        `${indent(depth + 1)}$whileSeq(() => ${test}, () => {`,
+        bodyStmts,
+        `${indent(depth + 1)}}, ${max}${optsSrc});`,
+        `${pad}}`
       ].join("\n");
     }
     case "ClassDeclaration": {
@@ -6342,6 +8840,8 @@ function transpileClass(stmt, depth, opts) {
   });
   const methodOpts = {
     ...opts,
+    inLoop: 0,
+    inTry: 0,
     thisParam: "__this",
     className: name
   };
@@ -6425,6 +8925,9 @@ ${indent(depth)}}`;
   }
   if (stmt.type === "ReturnStatement") {
     const v2 = stmt.argument ? transpileExpression(stmt.argument, opts) : "$lit(undefined)";
+    if ((opts.inLoop ?? 0) > 0) {
+      return `() => { $loopReturn(${v2}); }`;
+    }
     return `() => ${v2}`;
   }
   const one = transpileStatement(stmt, depth + 1, opts);
@@ -6466,15 +8969,53 @@ function transpileExpression(expr, opts = {}) {
     }
     case "LogicalExpression": {
       const op = expr.operator;
+      const lNode = expr.left;
+      const rNode = expr.right;
       const l = transpileExpression(expr.left, opts);
       const r = transpileExpression(expr.right, opts);
-      return op === "&&" ? `$fork(${l}, () => ${r}, () => ${l})` : `$fork(${l}, () => ${l}, () => ${r})`;
+      if (op === "??") {
+        return transpileShortCircuitExpr(opts, {
+          alwaysNodes: [lNode],
+          alwaysSrc: l,
+          // 测试用 nullish；返回侧：nullish → right，否则 → left
+          consSrc: r,
+          consNodes: [rNode],
+          altSrc: l,
+          altNodes: [lNode],
+          testSrc: `$nullishTest(${l})`
+        });
+      }
+      return op === "&&" ? transpileShortCircuitExpr(opts, {
+        alwaysNodes: [lNode],
+        alwaysSrc: l,
+        consSrc: r,
+        consNodes: [rNode],
+        altSrc: "__test",
+        altNodes: []
+      }) : transpileShortCircuitExpr(opts, {
+        alwaysNodes: [lNode],
+        alwaysSrc: l,
+        consSrc: "__test",
+        consNodes: [],
+        altSrc: r,
+        altNodes: [rNode]
+      });
     }
     case "ConditionalExpression": {
+      const testNode = expr.test;
+      const consNode = expr.consequent;
+      const altNode = expr.alternate;
       const test = transpileExpression(expr.test, opts);
       const c = transpileExpression(expr.consequent, opts);
       const a = transpileExpression(expr.alternate, opts);
-      return `$fork(${test}, () => ${c}, () => ${a})`;
+      return transpileShortCircuitExpr(opts, {
+        alwaysNodes: [testNode],
+        alwaysSrc: test,
+        consSrc: c,
+        consNodes: [consNode],
+        altSrc: a,
+        altNodes: [altNode]
+      });
     }
     case "RegExpLiteral": {
       return `$regex(${JSON.stringify(expr.pattern)}${expr.flags ? `, ${JSON.stringify(expr.flags)}` : ""})`;
@@ -6543,6 +9084,22 @@ function transpileExpression(expr, opts = {}) {
           acc = acc === null ? arg : `$spread(${acc}, ${arg})`;
           continue;
         }
+        if (prop.type === "ObjectMethod") {
+          flushProps();
+          const mkey = prop.key.type === "Identifier" ? JSON.stringify(prop.key.name) : prop.key.type === "StringLiteral" ? JSON.stringify(prop.key.value) : null;
+          if (mkey === null) continue;
+          const paramNames = prop.params.map(
+            (p) => p.type === "Identifier" && p.name ? p.name : "_a"
+          );
+          const methodOpts = { ...opts, inLoop: 0, inTry: 0, thisParam: "__this" };
+          const bodySrc = prop.body.type === "BlockStatement" ? `{
+${prop.body.body.map((s) => transpileStatement(s, 1, methodOpts)).join("\n")}
+}` : transpileExpression(prop.body, methodOpts);
+          const bindParams = ["__this", ...paramNames];
+          const fnValSrc = `$fnVal([${paramNames.map((p) => JSON.stringify(p)).join(", ")}], (${bindParams.join(", ")}) => ${bodySrc}, { bindThis: true })`;
+          props.push(`${mkey}: ${fnValSrc}`);
+          continue;
+        }
         if (prop.type !== "ObjectProperty") continue;
         if (prop.computed) {
           flushProps();
@@ -6554,6 +9111,23 @@ function transpileExpression(expr, opts = {}) {
         }
         const key = prop.key.type === "Identifier" ? JSON.stringify(prop.key.name) : prop.key.type === "StringLiteral" ? JSON.stringify(prop.key.value) : null;
         if (key === null) continue;
+        if (prop.value.type === "FunctionExpression" && !prop.value.async) {
+          const fn = prop.value;
+          if (!fn.generator) {
+            const paramNames = fn.params.map(
+              (p) => p.type === "Identifier" && p.name ? p.name : "_a"
+            );
+            const methodOpts = { ...opts, inLoop: 0, thisParam: "__this" };
+            const bodySrc = fn.body.type === "BlockStatement" ? `{
+${fn.body.body.map((s) => transpileStatement(s, 1, methodOpts)).join("\n")}
+}` : transpileExpression(fn.body, methodOpts);
+            const bindParams = ["__this", ...paramNames];
+            props.push(
+              `${key}: $fnVal([${paramNames.map((p) => JSON.stringify(p)).join(", ")}], (${bindParams.join(", ")}) => ${bodySrc}, { bindThis: true })`
+            );
+            continue;
+          }
+        }
         const valSrc = transpileExpression(prop.value, opts);
         props.push(`${key}: ${valSrc}`);
       }
@@ -6605,6 +9179,58 @@ function transpileExpression(expr, opts = {}) {
     case "AssignmentExpression": {
       const compoundFn = COMPOUND_OPS[expr.operator];
       const right = transpileExpression(expr.right, opts);
+      const op = expr.operator;
+      if (op === "||=" || op === "&&=" || op === "??=") {
+        const rNode = expr.right;
+        const emitLogicalAssign = (targetSrc, setSrc) => {
+          if (op === "||=") {
+            const sc2 = transpileShortCircuitExpr(opts, {
+              alwaysNodes: [],
+              alwaysSrc: targetSrc,
+              consSrc: "__test",
+              consNodes: [],
+              altSrc: right,
+              altNodes: [rNode]
+            });
+            return setSrc(sc2);
+          }
+          if (op === "&&=") {
+            const sc2 = transpileShortCircuitExpr(opts, {
+              alwaysNodes: [],
+              alwaysSrc: targetSrc,
+              consSrc: right,
+              consNodes: [rNode],
+              altSrc: "__test",
+              altNodes: []
+            });
+            return setSrc(sc2);
+          }
+          const sc = transpileShortCircuitExpr(opts, {
+            alwaysNodes: [],
+            alwaysSrc: targetSrc,
+            consSrc: right,
+            consNodes: [rNode],
+            altSrc: targetSrc,
+            altNodes: [],
+            testSrc: `$nullishTest(${targetSrc})`
+          });
+          return setSrc(sc);
+        };
+        if (expr.left.type === "Identifier") {
+          return emitLogicalAssign(expr.left.name, (val) => `${expr.left.type === "Identifier" ? expr.left.name : ""} = ${val}`);
+        }
+        if (expr.left.type === "MemberExpression") {
+          const m = expr.left;
+          const path = memberPathOf(m, opts);
+          if (path) {
+            return emitLogicalAssign(readPathSrc(path), (val) => {
+              const writeSrc = setPathSrc(path, val);
+              return `${path.rootSrc} = ${writeSrc}`;
+            });
+          }
+        }
+        return `/* assign ${op} */ $lit(undefined)`;
+      }
       if (expr.left.type === "MemberExpression") {
         const m = expr.left;
         const path = memberPathOf(m, opts);
@@ -6694,10 +9320,11 @@ function transpileExpression(expr, opts = {}) {
     case "FunctionExpression": {
       const fn = expr;
       const { sig, rest, prologue } = emitParamBinding(fn.params, indent(1), opts);
+      const fnBodyOpts = { ...opts, inLoop: 0 };
       const paramParts = rest ? [...sig, `...${rest}`] : sig;
       const nameList = `[${sig.map((p) => JSON.stringify(p)).join(", ")}]`;
       if (fn.body.type === "BlockStatement") {
-        const inner = [...prologue, transpileFnBodyStmts(fn.body.body, 1, opts)].join("\n");
+        const inner = [...prologue, transpileFnBodyStmts(fn.body.body, 1, fnBodyOpts)].join("\n");
         if (fn.async) {
           return `$fnVal(${nameList}, (${paramParts.join(", ")}) => $async(() => {
 ${inner}
@@ -6707,7 +9334,7 @@ ${inner}
 ${inner}
 })`;
       }
-      const bodySrc = transpileExpression(fn.body, opts);
+      const bodySrc = transpileExpression(fn.body, fnBodyOpts);
       if (prologue.length > 0) {
         const thunk = fn.async ? `$async(() => ${bodySrc})` : bodySrc;
         return `$fnVal(${nameList}, (${paramParts.join(", ")}) => {
@@ -6807,7 +9434,7 @@ function $new(cls, args) {
       if (args.length === 1) {
         const n = litValue(args[0]);
         if (typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= 4096) {
-          const els = Array.from({ length: n }, () => undefAbs());
+          const els = Array.from({ length: n }, () => undefAbs2());
           return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
         }
         return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
@@ -6818,9 +9445,14 @@ function $new(cls, args) {
       const p = args[0] ? litValue(args[0]) : void 0;
       if (typeof p === "string") return $regex(p, args[1] ? String(litValue(args[1]) ?? "") : "");
     }
-    const name = cls.name || "Object";
+    const clsName = cls.name || "Object";
+    if (isErrorCtorName(clsName)) {
+      return errorBrandAbs(clsName, args[0]);
+    }
+    if (clsName === "Map") return makeMapAbs(args[0]);
+    if (clsName === "Set") return makeSetAbs(args[0]);
     const shape = objOf({});
-    return abs({ k: "brand", name, shape }, void 0, void 0, "path");
+    return abs({ k: "brand", name: clsName, shape }, void 0, void 0, "path");
   }
   const spec = specOf(cls);
   if (!spec) {
@@ -6884,7 +9516,7 @@ function execRegexBrand(re, method, args) {
   if (!m) {
     return abs({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
   }
-  const els = m.map((g) => g === void 0 ? undefAbs() : strLit(g));
+  const els = m.map((g) => g === void 0 ? undefAbs2() : strLit(g));
   return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
 }
 function stringRegexMethod(recv, method, args) {
@@ -6917,10 +9549,69 @@ function stringRegexMethod(recv, method, args) {
   if (!m) {
     return abs({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
   }
-  const els = m.map((g) => g === void 0 ? undefAbs() : strLit(g));
+  const els = m.map((g) => g === void 0 ? undefAbs2() : strLit(g));
   return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
 }
 function $invoke(thisVal, method, args, loc) {
+  if (method === "call" || method === "apply" || method === "bind") {
+    const expandApplyArgs = (list) => {
+      if (list === null || list === void 0) return [];
+      if (Array.isArray(list)) {
+        return list.map(
+          (x) => x && typeof x === "object" && "shape" in x ? x : unknown
+        );
+      }
+      if (typeof list === "object" && "shape" in list) {
+        const s = list.shape;
+        if (s.k === "tuple") return [...s.elements];
+        if (s.k === "arr") return [s.element];
+      }
+      return [unknown];
+    };
+    const boundFnParams = (fnVal, boundCount) => {
+      if (fnVal && typeof fnVal === "object" && "shape" in fnVal) {
+        const s = fnVal.shape;
+        if (s.k === "fn" && Array.isArray(s.params)) {
+          return s.params.slice(boundCount);
+        }
+      }
+      if (typeof fnVal === "function") {
+        const arity = fnVal.length ?? 0;
+        const rem = Math.max(0, arity - boundCount);
+        return Array.from({ length: rem }, (_, i) => `_a${boundCount + i}`);
+      }
+      return ["_rest"];
+    };
+    if (typeof thisVal === "function") {
+      const fn = thisVal;
+      if (method === "call") {
+        return callAtFunctionBoundary(() => fn(...args.slice(1)));
+      }
+      if (method === "apply") {
+        return callAtFunctionBoundary(() => fn(...expandApplyArgs(args[1])));
+      }
+      const bound = args.slice(1);
+      return absFunction(boundFnParams(thisVal, bound.length), {
+        apply: (callArgs) => callAtFunctionBoundary(() => fn(...bound, ...callArgs))
+      });
+    }
+    if (thisVal && typeof thisVal === "object" && "shape" in thisVal) {
+      const fnImpl = getFnImpl(thisVal);
+      const isCallable = thisVal.shape.k === "fn" || fnImpl !== void 0;
+      if (isCallable) {
+        if (method === "call") {
+          return $call(thisVal, args.slice(1));
+        }
+        if (method === "apply") {
+          return $call(thisVal, expandApplyArgs(args[1]));
+        }
+        const bound = args.slice(1);
+        return absFunction(boundFnParams(thisVal, bound.length), {
+          apply: (callArgs) => callAtFunctionBoundary(() => $call(thisVal, [...bound, ...callArgs]))
+        });
+      }
+    }
+  }
   if (!thisVal || typeof thisVal !== "object" || !("shape" in thisVal)) {
     const ns = namespaceNameOf(thisVal);
     return (ns ? evalNamespaceCall(ns, method, args) : void 0) ?? unknown;
@@ -6936,6 +9627,10 @@ function $invoke(thisVal, method, args, loc) {
   }
   const brandName = thisVal.shape.k === "brand" ? thisVal.shape.name : void 0;
   if (brandName) {
+    if (brandName === "Map" || brandName === "Set") {
+      const viaCol = evalBuiltinInstanceMethod(brandName, method, thisVal, args);
+      if (viaCol !== void 0) return viaCol;
+    }
     const m = findMethod(brandName, method);
     if (m) return m(thisVal, ...args);
     const spec = getBClass(brandName);
@@ -6957,6 +9652,7 @@ function $invoke(thisVal, method, args, loc) {
   const prop = $get(thisVal, method, { silent: true });
   const impl = prop && typeof prop === "object" && "shape" in prop ? getFnImpl(prop) : void 0;
   if (impl) {
+    if (impl.bindThis) return $call(prop, [thisVal, ...args]);
     return $call(prop, args);
   }
   if (notePrimMemberMissing(thisVal, method, "method", loc)) return unknown;
@@ -6974,8 +9670,21 @@ function memberLikelyHasMethod(m, method) {
 function invokeArrMethod(arr, method, args) {
   const shape = arr.shape;
   const callFn = (fn, ...fnArgs) => {
+    const sumIdx = fnArgs.findIndex(
+      (a) => a && typeof a === "object" && "shape" in a && a.shape.k === "sum"
+    );
+    if (sumIdx >= 0) {
+      const members = fnArgs[sumIdx].shape.members;
+      let acc;
+      for (const m of members) {
+        const next = fnArgs.map((a, i) => i === sumIdx ? m : a);
+        const r = callFn(fn, ...next);
+        acc = acc === void 0 ? r : joinAbs(acc, r);
+      }
+      return acc ?? unknown;
+    }
     if (typeof fn === "function") {
-      const r = fn(...fnArgs);
+      const r = callAtFunctionBoundary(() => fn(...fnArgs));
       if (r && typeof r === "object" && "shape" in r) return r;
       return unknown;
     }
@@ -7033,7 +9742,7 @@ function invokeArrMethod(arr, method, args) {
   if (method === "forEach" && args[0]) {
     const list = shape.k === "tuple" ? shape.elements : [shape.element];
     for (const el of list) callFn(args[0], el);
-    return undefAbs();
+    return undefAbs2();
   }
   if ((method === "some" || method === "every") && args[0]) {
     const list = shape.k === "tuple" ? shape.elements : [shape.element];
@@ -7043,7 +9752,7 @@ function invokeArrMethod(arr, method, args) {
   if (method === "find" && args[0]) {
     const el = shape.k === "tuple" ? shape.elements[0] ?? unknown : shape.element;
     callFn(args[0], el);
-    return joinAbs(el, undefAbs());
+    return joinAbs(el, undefAbs2());
   }
   if (method === "join") {
     return abs({ k: "prim", type: "string" }, void 0, void 0, "path");
@@ -7063,11 +9772,35 @@ function invokeArrMethod(arr, method, args) {
   if (method === "includes") {
     return abs({ k: "prim", type: "boolean" }, void 0, void 0, "partial");
   }
-  if (method === "at" || method === "pop" || method === "shift") {
+  if (method === "push" || method === "unshift") {
+    return abs({ k: "prim", type: "number" }, void 0, void 0, "path");
+  }
+  if (method === "pop") {
+    if (shape.k === "tuple") {
+      return shape.elements.length > 0 ? shape.elements[shape.elements.length - 1] ?? unknown : undefAbs2();
+    }
+    if (shape.k === "arr") return joinAbs(shape.element, undefAbs2());
+  }
+  if (method === "shift") {
     if (shape.k === "tuple" && shape.elements.length > 0) {
       return shape.elements[0] ?? unknown;
     }
-    if (shape.k === "arr") return shape.element;
+    if (shape.k === "arr") return joinAbs(shape.element, undefAbs2());
+  }
+  if (method === "at") {
+    const raw = args[0] !== void 0 ? litValue(args[0]) : void 0;
+    const iv = typeof raw === "number" && Number.isInteger(raw) ? raw : void 0;
+    if (shape.k === "tuple") {
+      const els = shape.elements;
+      if (iv === void 0) {
+        if (els.length === 0) return undefAbs2();
+        return joinAbs(els.reduce((a, b) => joinAbs(a, b)), undefAbs2());
+      }
+      const idx = iv < 0 ? els.length + iv : iv;
+      if (idx >= 0 && idx < els.length) return els[idx] ?? unknown;
+      return undefAbs2();
+    }
+    if (shape.k === "arr") return joinAbs(shape.element, undefAbs2());
   }
   return void 0;
 }
@@ -7109,13 +9842,32 @@ function $thisSet(thisVal, key, value) {
 }
 function $orDefault(v2, dflt) {
   if (v2 === void 0) return asAbsVal(dflt());
-  if (litValue(v2) === void 0 && v2.shape.k !== "never") {
-    if (v2.term?.op === "lit" && v2.term.value === void 0) return asAbsVal(dflt());
-    if (v2.shape.k === "unknown" && v2.term?.op === "lit") return asAbsVal(dflt());
+  if (isDefinitelyUndefinedAbs(v2)) return asAbsVal(dflt());
+  if (v2.shape.k === "sum") {
+    const d = asAbsVal(dflt());
+    const parts = [];
+    let sawUndef = false;
+    for (const m of v2.shape.members) {
+      if (isDefinitelyUndefinedAbs(m)) {
+        sawUndef = true;
+        continue;
+      }
+      parts.push(m);
+    }
+    if (!sawUndef) return v2;
+    if (parts.length === 0) return d;
+    let joined = parts[0];
+    for (let i = 1; i < parts.length; i++) joined = joinAbs(joined, parts[i]);
+    return joinAbs(joined, d);
   }
-  if (v2.term?.op === "lit" && v2.term.value === void 0) return asAbsVal(dflt());
   return v2;
 }
+function isDefinitelyUndefinedAbs(v2) {
+  if (!v2) return false;
+  if (v2.term?.op === "lit" && v2.term.value === void 0) return true;
+  if (v2.shape.k === "unknown" && v2.term?.op === "lit" && litValue(v2) === void 0) return true;
+  return false;
+}
 function isNullishAbs(v2) {
   if (!v2 || v2.term?.op !== "lit") return false;
   const lv = v2.term.value;
@@ -7154,11 +9906,47 @@ function $setKey(o, key, value) {
   if (typeof k === "string" || typeof k === "number") {
     return $set(o, String(k), value);
   }
-  return $set(o, "?", value);
+  const val = asAbsVal(value);
+  if (o.shape.k === "brand") {
+    const inner = $setKey(o.shape.shape, key, value);
+    return abs(
+      { k: "brand", name: o.shape.name, shape: inner },
+      o.term,
+      o.pred,
+      confJoin(o.conf, value.conf)
+    );
+  }
+  if (o.shape.k !== "obj") {
+    return abs(
+      {
+        k: "obj",
+        slots: {},
+        index: { key: unknown, value: val },
+        open: true
+      },
+      void 0,
+      void 0,
+      confJoin("path", value.conf)
+    );
+  }
+  const shape = o.shape;
+  const prevIndex = shape.index?.value;
+  const indexVal = prevIndex ? joinAbs(prevIndex, val) : val;
+  const next = objOf({ ...shape.slots }, {
+    index: { key: shape.index?.key ?? unknown, value: indexVal },
+    open: true
+  });
+  next.conf = confJoin(o.conf, value.conf);
+  return next;
 }
 
 // src/algebra/exec/run.ts
 var rtAll = { ...runtime_exports, ...class_exports, ...calls_exports };
+rtAll.isNudoReturn = isNudoReturn;
+rtAll.isNudoThrow = isNudoThrow;
+rtAll.$isForkExit = $isForkExit;
+rtAll.runWithLoopExits = runWithLoopExits;
+rtAll.takeLoopExits = takeLoopExits;
 var RUNTIME_IMPORT_RE = /^import\s*\{[^}]+\}\s*from\s*"[^"]+";\s*$/m;
 function rewriteUserImports(js) {
   js = js.replace(
@@ -7364,33 +10152,59 @@ function isAbsVal(v2) {
 function callTranspiledExportFull(exports, name, args) {
   const fn = exports[name];
   if (typeof fn === "function") {
-    try {
-      const r = fn(...args);
-      if (!isAbsVal(r)) return { result: unknown, throws: never };
-      return { result: r, throws: never };
-    } catch (e) {
-      if (isNudoThrow(e)) {
-        return { result: never, throws: e.absValue };
-      }
-      return { result: unknown, throws: never };
-    }
-  }
-  if (isAbsVal(fn)) {
-    if (fn.shape.k === "fn") {
+    return runWithLoopExits(() => {
       try {
-        const r = $call(fn, args);
-        return { result: r, throws: never };
+        const r = fn(...args);
+        if (!isAbsVal(r)) return joinControlExits(unknown);
+        return joinControlExits(r);
       } catch (e) {
+        if (isNudoReturn(e)) {
+          return joinControlExits(e.absValue);
+        }
         if (isNudoThrow(e)) {
-          return { result: never, throws: e.absValue };
+          const result = joinLoopExits(never);
+          const throws = joinThrowExits(e.absValue);
+          return { result, throws };
         }
-        return { result: unknown, throws: never };
+        return joinControlExits(unknown);
       }
+    });
+  }
+  if (isAbsVal(fn)) {
+    if (fn.shape.k === "fn") {
+      return runWithLoopExits(() => {
+        try {
+          const r = $call(fn, args);
+          return joinControlExits(r);
+        } catch (e) {
+          if (isNudoReturn(e)) {
+            return joinControlExits(e.absValue);
+          }
+          if (isNudoThrow(e)) {
+            return { result: joinLoopExits(never), throws: joinThrowExits(e.absValue) };
+          }
+          return joinControlExits(unknown);
+        }
+      });
     }
     return { result: fn, throws: never };
   }
   return { result: unknown, throws: never };
 }
+function joinLoopExits(normal) {
+  const exits = takeLoopExits();
+  if (exits.length === 0) return normal;
+  return exits.reduce((acc, x) => joinAbs(acc, x), normal);
+}
+function joinThrowExits(base) {
+  const exits = takeThrowExits();
+  let t = base;
+  for (const x of exits) t = t ? joinAbs(t, x) : x;
+  return t ?? never;
+}
+function joinControlExits(normal) {
+  return { result: joinLoopExits(normal), throws: joinThrowExits(void 0) };
+}
 function callTranspiledExport(exports, name, args) {
   return callTranspiledExportFull(exports, name, args).result;
 }
@@ -7494,7 +10308,7 @@ export {
   instantiateReturn,
   setApplyCallbackHost,
   applyCallbackAbs,
-  undefAbs,
+  undefAbs2 as undefAbs,
   mapElementFallback,
   projectFlatMapResult,
   asAbs,
@@ -7530,6 +10344,34 @@ export {
   definitelyNotNullishShape,
   isNullishLitAbs,
   strictEqAbs,
+  looseEqAbs,
+  pushCollectionArm,
+  popCollectionArm,
+  mergeCollectionArms,
+  beginCollectionFork,
+  noteCollectionWrite,
+  endCollectionFork,
+  isMapAbs,
+  isSetAbs,
+  makeMapAbs,
+  makeSetAbs,
+  mapSetEntry,
+  mapDeleteEntry,
+  mapClearEntries,
+  mapGetEntry,
+  mapHasEntry,
+  mapSizeAbs,
+  mapValuesAbs,
+  mapEntriesAbs,
+  setAddEntry,
+  setDeleteEntry,
+  setClearEntries,
+  setHasEntry,
+  setSizeAbs,
+  setElementsAbs,
+  collectionExactLen,
+  collectionElementJoin,
+  clearCollectionTables,
   evalMathMethod,
   evalObjectMethod,
   evalJsonMethod,
@@ -7544,6 +10386,8 @@ export {
   evalPromiseCtor,
   evalPromiseStatic,
   evalNamespaceCall,
+  isErrorCtorName,
+  errorBrandAbs,
   evalBuiltinNew,
   evalBuiltinInstanceMethod,
   callAbsMethod,
@@ -7577,6 +10421,10 @@ export {
   notePrimMemberMissing,
   noteUnknownMemberMissing,
   noteMemberDispatchMiss,
+  setEvalMissingSlotEnabled,
+  isEvalMissingSlotEnabled,
+  runWithEvalMissingSlot,
+  noteObjSlotMissing,
   registerBClass,
   getBClass,
   clearBClasses,
@@ -7618,27 +10466,44 @@ export {
   $not,
   $eq,
   $ne,
+  $eqLoose,
+  $neLoose,
   $lt,
   $le,
   $gt,
   $ge,
   $join,
   asAbsVal,
+  callAtFunctionBoundary,
   $fnVal,
   $lit,
   litTruth,
   isDefinitelyTrue,
   isDefinitelyFalse,
+  runWithLoopExits,
+  takeLoopExits,
+  takeThrowExits,
+  pushLoopExit,
+  pushThrowExit,
+  $pushLoopExit,
+  $tryMark,
+  $tryCurrentMark,
+  $tryPopMark,
+  $tryTakeSince,
   $fork,
   DEFAULT_MAX_LOOP_ITERS,
   $forIter,
   $for,
   $arr,
+  isArrMutator,
+  $arrMutContainer,
   $idx,
   $idxSet,
   $len,
   $obj,
   $spread,
+  $objRest,
+  $arrRest,
   $concat,
   $elems,
   $forOf,
@@ -7648,9 +10513,14 @@ export {
   $set,
   $while,
   $whileSeq,
+  NudoReturn,
+  $loopReturn,
+  isNudoReturn,
+  $rethrowIfNudoReturn,
   NudoThrow,
   $throw,
   isNudoThrow,
+  $isForkExit,
   $catchVal,
   $async,
   $await,
@@ -7658,6 +10528,7 @@ export {
   $gen,
   $yield,
   $switch,
+  $nullishTest,
   transpileSource,
   transpileFile,
   transpileExpression,