@nudojs/core 0.3.1 → 0.4.0

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

@@ -39,6 +39,7 @@ __export(runtime_exports, {
   $neg: () => $neg,
   $not: () => $not,
   $obj: () => $obj,
+  $regex: () => $regex,
   $set: () => $set,
   $spread: () => $spread,
   $sub: () => $sub,
@@ -55,6 +56,8 @@ __export(runtime_exports, {
   isDefinitelyFalse: () => isDefinitelyFalse,
   isDefinitelyTrue: () => isDefinitelyTrue,
   isNudoThrow: () => isNudoThrow,
+  litTruth: () => litTruth,
+  namespaceNameOf: () => namespaceNameOf,
   withExecPhi: () => withExecPhi
 });
 
@@ -873,6 +876,9 @@ function isAnyLike(a) {
   if (a.shape.k === "unknown") return true;
   return false;
 }
+function coercibleLit(v2) {
+  return v2 !== void 0 && (typeof v2 === "number" || typeof v2 === "string" || typeof v2 === "boolean" || v2 === null);
+}
 function toNumberResult(a, b, op) {
   const term = a.term && b.term ? simplifyTerm(app(op, [a.term, b.term])) : void 0;
   return abs(
@@ -991,6 +997,9 @@ function sub(a, b, phi2 = pTrue) {
   if (typeof va === "number" && typeof vb === "number") {
     return numLit(va - vb);
   }
+  if (coercibleLit(va) && coercibleLit(vb)) {
+    return numLit(Number(va) - Number(vb));
+  }
   if (isNumericLike(a) && isNumericLike(b) && a.term && b.term) {
     const term = simplifyTerm(app("-", [a.term, b.term]));
     const ab = numericBounds(a, phi2);
@@ -1023,6 +1032,9 @@ function mul(a, b, phi2 = pTrue) {
   if (typeof va === "number" && typeof vb === "number") {
     return numLit(va * vb);
   }
+  if (coercibleLit(va) && coercibleLit(vb)) {
+    return numLit(Number(va) * Number(vb));
+  }
   if (isNumericLike(a) && isNumericLike(b) && a.term && b.term) {
     const term = simplifyTerm(app("*", [a.term, b.term]));
     if (b.term.op === "lit" && b.term.value === 0 || a.term.op === "lit" && a.term.value === 0) {
@@ -1089,6 +1101,9 @@ function div(a, b, phi2 = pTrue) {
     }
     return numLit(va / vb);
   }
+  if (coercibleLit(va) && coercibleLit(vb)) {
+    return numLit(Number(va) / Number(vb));
+  }
   if (isNumericLike(a) && isNumericLike(b) && a.term && b.term) {
     const term = simplifyTerm(app("/", [a.term, b.term]));
     if (b.term.op === "lit" && typeof b.term.value === "number" && b.term.value !== 0) {
@@ -1131,6 +1146,9 @@ function mod(a, b, phi2 = pTrue) {
     }
     return numLit(va % vb);
   }
+  if (coercibleLit(va) && coercibleLit(vb)) {
+    return numLit(Number(va) % Number(vb));
+  }
   if (isNumericLike(a) && isNumericLike(b) && a.term && b.term) {
     const term = simplifyTerm(app("%", [a.term, b.term]));
     if (b.term.op === "lit" && typeof b.term.value === "number" && b.term.value !== 0) {
@@ -1981,159 +1999,484 @@ function primOf(a) {
   return void 0;
 }
 
-// src/algebra/exec/calls.ts
-var calls_exports = {};
-__export(calls_exports, {
-  $callNamed: () => $callNamed,
-  getAbsOrigin: () => getAbsOrigin,
-  getBCallCollector: () => getBCallCollector,
-  noteMemberDispatchMiss: () => noteMemberDispatchMiss,
-  notePrimMemberMissing: () => notePrimMemberMissing,
-  noteUnknownMemberMissing: () => noteUnknownMemberMissing,
-  recordMemberDiag: () => recordMemberDiag,
-  setBCallCollector: () => setBCallCollector,
-  setMemberDiagCollector: () => setMemberDiagCollector,
-  tagAbsOrigin: () => tagAbsOrigin
-});
-
-// src/algebra/parse-source.ts
-import { parse as babelParse } from "@babel/parser";
-
-// src/strip-types.ts
-var REMOVE = Symbol("nudo.strip.remove");
-var SKIP_KEYS = /* @__PURE__ */ new Set([
-  "loc",
-  "start",
-  "end",
-  "range",
-  "leadingComments",
-  "trailingComments",
-  "innerComments",
-  "comments",
-  "tokens",
-  "extra"
-]);
-function transformValue(value) {
-  if (Array.isArray(value)) {
-    let changed = false;
-    const out = [];
-    for (const el of value) {
-      if (el === null || el === void 0) {
-        out.push(el);
-        continue;
+// src/algebra/builtins.ts
+function numPrim(conf = "path") {
+  return abs({ k: "prim", type: "number" }, void 0, void 0, conf);
+}
+function strPrim(conf = "path") {
+  return abs({ k: "prim", type: "string" }, void 0, void 0, conf);
+}
+function boolPrim(conf = "partial") {
+  return abs({ k: "prim", type: "boolean" }, void 0, void 0, conf);
+}
+function evalMathMethod(name, args) {
+  const a0 = args[0] ? litValue(args[0]) : void 0;
+  const a1 = args[1] ? litValue(args[1]) : void 0;
+  switch (name) {
+    case "abs":
+      if (typeof a0 === "number") return numLit(Math.abs(a0));
+      return numPrim();
+    case "floor":
+      if (typeof a0 === "number") return numLit(Math.floor(a0));
+      return numPrim();
+    case "ceil":
+      if (typeof a0 === "number") return numLit(Math.ceil(a0));
+      return numPrim();
+    case "round":
+      if (typeof a0 === "number") return numLit(Math.round(a0));
+      return numPrim();
+    case "sqrt":
+      if (typeof a0 === "number") return numLit(Math.sqrt(a0));
+      return numPrim();
+    case "min": {
+      const lits = args.map(litValue);
+      if (lits.length > 0 && lits.every((x) => typeof x === "number")) {
+        return numLit(Math.min(...lits));
       }
-      const r = transformValue(el);
-      if (r === REMOVE) {
-        changed = true;
-      } else {
-        if (r !== el) changed = true;
-        out.push(r);
+      return numPrim();
+    }
+    case "max": {
+      const lits = args.map(litValue);
+      if (lits.length > 0 && lits.every((x) => typeof x === "number")) {
+        return numLit(Math.max(...lits));
       }
+      return numPrim();
     }
-    return changed ? out : value;
-  }
-  if (typeof value !== "object" || value === null) return value;
-  if (typeof value.type !== "string") return value;
-  return transformNode(value);
-}
-function isTsDeclareLike(node) {
-  return node.declare === true;
-}
-function isTypeOnlyDeclaration(decl) {
-  switch (decl.type) {
-    case "TSInterfaceDeclaration":
-    case "TSTypeAliasDeclaration":
-    case "TSEnumDeclaration":
-    case "TSDeclareFunction":
-      return true;
-    case "VariableDeclaration":
-    case "ClassDeclaration":
-      return isTsDeclareLike(decl);
+    case "pow":
+      if (typeof a0 === "number" && typeof a1 === "number") return numLit(Math.pow(a0, a1));
+      return numPrim();
+    case "sign":
+      if (typeof a0 === "number") return numLit(Math.sign(a0));
+      return numPrim();
     default:
-      return false;
+      return void 0;
   }
 }
-function isTypeOnlyStatement(node) {
-  const anyNode = node;
-  switch (node.type) {
-    case "TSInterfaceDeclaration":
-    case "TSTypeAliasDeclaration":
-    case "TSEnumDeclaration":
-    case "TSDeclareFunction":
-      return true;
-    case "TSModuleDeclaration":
-      return isTsDeclareLike(node);
-    case "VariableDeclaration":
-    case "ClassDeclaration":
-      return isTsDeclareLike(node);
-    case "ImportDeclaration":
-      if (anyNode.importKind === "type") return true;
-      {
-        const specs = anyNode.specifiers;
-        if (specs && specs.length > 0 && specs.every((s) => s.importKind === "type" || s.importKind === "typeof")) {
-          return true;
-        }
+function evalObjectMethod(name, args) {
+  const a0 = args[0];
+  switch (name) {
+    case "keys": {
+      if (a0?.shape.k === "obj") {
+        const keys = Object.keys(a0.shape.slots).map(
+          (k) => strLit(k)
+        );
+        return abs({ k: "tuple", elements: keys }, void 0, void 0, "exact");
       }
-      return false;
-    case "ExportNamedDeclaration": {
-      if (anyNode.exportKind === "type") return true;
-      const decl = node.declaration;
-      if (decl && isTypeOnlyDeclaration(decl)) return true;
-      {
-        const specs = anyNode.specifiers;
-        if (!decl && specs && specs.length > 0 && specs.every((s) => s.exportKind === "type")) return true;
+      return abs({ k: "arr", element: strPrim("path") }, void 0, void 0, "partial");
+    }
+    case "values": {
+      if (a0?.shape.k === "obj") {
+        const slots = a0.shape.slots;
+        const vals = Object.values(slots).map((s) => s.value);
+        return abs({ k: "tuple", elements: vals }, void 0, void 0, "exact");
       }
-      return false;
+      return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
+    }
+    case "entries": {
+      if (a0?.shape.k === "obj") {
+        const slots = a0.shape.slots;
+        const entries = Object.entries(slots).map(
+          ([, s]) => abs({ k: "tuple", elements: [strPrim("exact"), s.value] }, void 0, void 0, "exact")
+        );
+        return abs({ k: "tuple", elements: entries }, void 0, void 0, "exact");
+      }
+      return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
+    }
+    case "assign": {
+      if (!args.length) return unknown;
+      let acc = args[0];
+      for (let i = 1; i < args.length; i++) {
+        acc = { ...acc };
+        if (acc.shape.k === "obj" && args[i].shape.k === "obj") {
+          const base = acc.shape.slots;
+          const over = args[i].shape.slots;
+          acc = abs({ k: "obj", slots: { ...base, ...over } }, void 0, void 0, confJoin(acc.conf, args[i].conf));
+        }
+      }
+      return acc;
     }
-    case "ExportAllDeclaration":
-      return anyNode.exportKind === "type";
-    case "ExportDefaultDeclaration":
-      return isTypeOnlyDeclaration(node.declaration);
-    // ---- 类成员 ----
-    case "TSIndexSignature":
-    case "TSDeclareMethod":
-      return true;
-    case "ClassProperty":
-    case "ClassPrivateProperty":
-      return isTsDeclareLike(node) || node.abstract === true;
     default:
-      return false;
+      return void 0;
   }
 }
-function deleteTypeSyntaxFields(node) {
-  const tp = node.typeParameters;
-  if (tp && typeof tp.type === "string" && tp.type.startsWith("TSTypeParameter")) {
-    delete node.typeParameters;
-  }
-  const ta = node.typeAnnotation;
-  if (ta && ta.type === "TSTypeAnnotation") delete node.typeAnnotation;
-  const rt = node.returnType;
-  if (rt && (rt.type === "TSTypeAnnotation" || rt.type === "TSTypePredicate")) delete node.returnType;
-  if (node.optional === true && (node.type === "Identifier" || node.type === "ObjectPattern" || node.type === "ArrayPattern" || node.type === "RestElement")) {
-    delete node.optional;
-  }
-  if ("implements" in node) delete node.implements;
-  if ("superTypeParameters" in node) delete node.superTypeParameters;
+function evalJsonMethod(name, args) {
+  if (name === "stringify") return strPrim("partial");
+  if (name === "parse") return unknown;
+  return void 0;
 }
-function unwrapExpression(node) {
-  switch (node.type) {
-    case "TSAsExpression":
-    // 含 as const
-    case "TSSatisfiesExpression":
-    case "TSTypeAssertion":
-    case "TSNonNullExpression":
-    case "TSInstantiationExpression":
-      return node.expression;
+function evalNumberStatic(name, args) {
+  const a0 = args[0] ? litValue(args[0]) : void 0;
+  switch (name) {
+    case "isInteger":
+      if (typeof a0 === "number") return boolLit(Number.isInteger(a0));
+      return boolPrim();
+    case "isNaN":
+      if (typeof a0 === "number") return boolLit(Number.isNaN(a0));
+      return boolPrim();
+    case "isFinite":
+      if (typeof a0 === "number") return boolLit(Number.isFinite(a0));
+      return boolPrim();
+    case "parseInt":
+    case "parseFloat":
+      if (typeof a0 === "string" || typeof a0 === "number") {
+        const n = name === "parseInt" ? parseInt(String(a0), 10) : parseFloat(String(a0));
+        return numLit(n);
+      }
+      return numPrim();
+    case "MAX_SAFE_INTEGER":
+      return numLit(Number.MAX_SAFE_INTEGER);
     default:
-      return null;
+      return void 0;
   }
 }
-function transformNode(node) {
-  if (isTypeOnlyStatement(node)) return REMOVE;
-  deleteTypeSyntaxFields(node);
-  if (node.type === "ImportDeclaration") {
-    node.specifiers = node.specifiers.filter(
-      (s) => !(s.importKind === "type" || s.importKind === "typeof")
+function evalGlobalFn(name, args) {
+  const a0 = args[0] ? litValue(args[0]) : void 0;
+  switch (name) {
+    case "parseInt":
+      if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseInt(String(a0), 10));
+      return numPrim();
+    case "parseFloat":
+      if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseFloat(String(a0)));
+      return numPrim();
+    case "isNaN":
+      if (typeof a0 === "number") return boolLit(Number.isNaN(a0));
+      return boolPrim();
+    case "Number":
+      if (typeof a0 === "number") return numLit(a0);
+      if (typeof a0 === "string") return numLit(Number(a0));
+      if (typeof a0 === "boolean") return numLit(a0 ? 1 : 0);
+      return numPrim();
+    case "String":
+      if (a0 !== void 0) return strLit(String(a0));
+      return strPrim();
+    case "Boolean":
+      if (a0 !== void 0) return boolLit(Boolean(a0));
+      return boolPrim();
+    default:
+      return void 0;
+  }
+}
+function evalArrayStatic(name, args) {
+  const a0 = args[0];
+  switch (name) {
+    case "isArray": {
+      if (!a0) return boolLit(false);
+      const k = a0.shape.k;
+      return boolLit(k === "arr" || k === "tuple");
+    }
+    case "from":
+    case "of":
+      return abs({ k: "arr", element: a0 ?? unknown }, void 0, void 0, "path");
+    default:
+      return void 0;
+  }
+}
+function evalDateCtor(args) {
+  return abs(
+    { k: "brand", name: "Date", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
+    void 0,
+    void 0,
+    "path"
+  );
+}
+function evalDateStatic(name, _args) {
+  if (name === "now") return numLit(Date.now());
+  return void 0;
+}
+function evalDateMethod(name, _recv, _args) {
+  switch (name) {
+    case "getTime":
+    case "valueOf":
+      return numPrim("path");
+    case "toISOString":
+    case "toString":
+      return strPrim("path");
+    default:
+      return void 0;
+  }
+}
+function evalRegExpCtor(_args) {
+  return abs(
+    { k: "brand", name: "RegExp", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
+    void 0,
+    void 0,
+    "path"
+  );
+}
+function evalRegExpMethod(name, _recv, _args) {
+  switch (name) {
+    case "test":
+      return boolPrim();
+    case "exec":
+      return unknown;
+    default:
+      return void 0;
+  }
+}
+function evalPromiseCtor(_args) {
+  return abs(
+    { k: "eff", eff: "promise", inner: unknown },
+    void 0,
+    void 0,
+    "partial"
+  );
+}
+function evalPromiseStatic(name, args) {
+  switch (name) {
+    case "resolve": {
+      const inner = args[0] ?? unknown;
+      if (inner.shape.k === "eff" && inner.shape.eff === "promise") return inner;
+      return abs({ k: "eff", eff: "promise", inner }, void 0, void 0, "path");
+    }
+    case "reject":
+      return abs({ k: "eff", eff: "promise", inner: unknown }, void 0, void 0, "partial");
+    case "all": {
+      const a0 = args[0];
+      if (a0?.shape.k === "arr" && a0.shape.element.shape.k === "eff") {
+        return abs(
+          { k: "eff", eff: "promise", inner: abs({ k: "arr", element: a0.shape.element.shape.inner }, void 0, void 0, "path") },
+          void 0,
+          void 0,
+          "path"
+        );
+      }
+      return abs({ k: "eff", eff: "promise", inner: abs({ k: "arr", element: unknown }, void 0, void 0, "partial") }, void 0, void 0, "partial");
+    }
+    default:
+      return void 0;
+  }
+}
+function evalNamespaceCall(ns, method, args) {
+  switch (ns) {
+    case "Math":
+      return evalMathMethod(method, args);
+    case "Object":
+      return evalObjectMethod(method, args);
+    case "JSON":
+      return evalJsonMethod(method, args);
+    case "Number":
+      return evalNumberStatic(method, args);
+    case "Array":
+      return evalArrayStatic(method, args);
+    case "Date":
+      return evalDateStatic(method, args);
+    case "Promise":
+      return evalPromiseStatic(method, args);
+    default:
+      return void 0;
+  }
+}
+function evalBuiltinNew(className, args) {
+  switch (className) {
+    case "Date":
+      return evalDateCtor(args);
+    case "RegExp":
+      return evalRegExpCtor(args);
+    case "Promise":
+      return evalPromiseCtor(args);
+    case "Map":
+      return abs(
+        { k: "brand", name: "Map", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
+        void 0,
+        void 0,
+        "path"
+      );
+    case "Set":
+      return abs(
+        { k: "brand", name: "Set", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
+        void 0,
+        void 0,
+        "path"
+      );
+    default:
+      return void 0;
+  }
+}
+function evalBuiltinInstanceMethod(brandName, method, recv, args) {
+  if (brandName === "Date") return evalDateMethod(method, recv, args);
+  if (brandName === "RegExp") return evalRegExpMethod(method, recv, args);
+  if (brandName === "Map") {
+    switch (method) {
+      case "get":
+        return unknown;
+      case "has":
+        return boolPrim();
+      case "set":
+        return recv;
+      case "size":
+        return numPrim("path");
+      default:
+        return void 0;
+    }
+  }
+  if (brandName === "Set") {
+    switch (method) {
+      case "has":
+        return boolPrim();
+      case "add":
+        return recv;
+      case "size":
+        return numPrim("path");
+      default:
+        return void 0;
+    }
+  }
+  return void 0;
+}
+
+// src/algebra/exec/calls.ts
+var calls_exports = {};
+__export(calls_exports, {
+  $callNamed: () => $callNamed,
+  getAbsOrigin: () => getAbsOrigin,
+  getBCallCollector: () => getBCallCollector,
+  noteMemberDispatchMiss: () => noteMemberDispatchMiss,
+  notePrimMemberMissing: () => notePrimMemberMissing,
+  noteUnknownMemberMissing: () => noteUnknownMemberMissing,
+  recordMemberDiag: () => recordMemberDiag,
+  setBCallCollector: () => setBCallCollector,
+  setMemberDiagCollector: () => setMemberDiagCollector,
+  tagAbsOrigin: () => tagAbsOrigin
+});
+
+// src/algebra/parse-source.ts
+import { parse as babelParse } from "@babel/parser";
+
+// src/strip-types.ts
+var REMOVE = Symbol("nudo.strip.remove");
+var SKIP_KEYS = /* @__PURE__ */ new Set([
+  "loc",
+  "start",
+  "end",
+  "range",
+  "leadingComments",
+  "trailingComments",
+  "innerComments",
+  "comments",
+  "tokens",
+  "extra"
+]);
+function transformValue(value) {
+  if (Array.isArray(value)) {
+    let changed = false;
+    const out = [];
+    for (const el of value) {
+      if (el === null || el === void 0) {
+        out.push(el);
+        continue;
+      }
+      const r = transformValue(el);
+      if (r === REMOVE) {
+        changed = true;
+      } else {
+        if (r !== el) changed = true;
+        out.push(r);
+      }
+    }
+    return changed ? out : value;
+  }
+  if (typeof value !== "object" || value === null) return value;
+  if (typeof value.type !== "string") return value;
+  return transformNode(value);
+}
+function isTsDeclareLike(node) {
+  return node.declare === true;
+}
+function isTypeOnlyDeclaration(decl) {
+  switch (decl.type) {
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "TSEnumDeclaration":
+    case "TSDeclareFunction":
+      return true;
+    case "VariableDeclaration":
+    case "ClassDeclaration":
+      return isTsDeclareLike(decl);
+    default:
+      return false;
+  }
+}
+function isTypeOnlyStatement(node) {
+  const anyNode = node;
+  switch (node.type) {
+    case "TSInterfaceDeclaration":
+    case "TSTypeAliasDeclaration":
+    case "TSEnumDeclaration":
+    case "TSDeclareFunction":
+      return true;
+    case "TSModuleDeclaration":
+      return isTsDeclareLike(node);
+    case "VariableDeclaration":
+    case "ClassDeclaration":
+      return isTsDeclareLike(node);
+    case "ImportDeclaration":
+      if (anyNode.importKind === "type") return true;
+      {
+        const specs = anyNode.specifiers;
+        if (specs && specs.length > 0 && specs.every((s) => s.importKind === "type" || s.importKind === "typeof")) {
+          return true;
+        }
+      }
+      return false;
+    case "ExportNamedDeclaration": {
+      if (anyNode.exportKind === "type") return true;
+      const decl = node.declaration;
+      if (decl && isTypeOnlyDeclaration(decl)) return true;
+      {
+        const specs = anyNode.specifiers;
+        if (!decl && specs && specs.length > 0 && specs.every((s) => s.exportKind === "type")) return true;
+      }
+      return false;
+    }
+    case "ExportAllDeclaration":
+      return anyNode.exportKind === "type";
+    case "ExportDefaultDeclaration":
+      return isTypeOnlyDeclaration(node.declaration);
+    // ---- 类成员 ----
+    case "TSIndexSignature":
+    case "TSDeclareMethod":
+      return true;
+    case "ClassProperty":
+    case "ClassPrivateProperty":
+      return isTsDeclareLike(node) || node.abstract === true;
+    default:
+      return false;
+  }
+}
+function deleteTypeSyntaxFields(node) {
+  const tp = node.typeParameters;
+  if (tp && typeof tp.type === "string" && tp.type.startsWith("TSTypeParameter")) {
+    delete node.typeParameters;
+  }
+  const ta = node.typeAnnotation;
+  if (ta && ta.type === "TSTypeAnnotation") delete node.typeAnnotation;
+  const rt = node.returnType;
+  if (rt && (rt.type === "TSTypeAnnotation" || rt.type === "TSTypePredicate")) delete node.returnType;
+  if (node.optional === true && (node.type === "Identifier" || node.type === "ObjectPattern" || node.type === "ArrayPattern" || node.type === "RestElement")) {
+    delete node.optional;
+  }
+  if ("implements" in node) delete node.implements;
+  if ("superTypeParameters" in node) delete node.superTypeParameters;
+}
+function unwrapExpression(node) {
+  switch (node.type) {
+    case "TSAsExpression":
+    // 含 as const
+    case "TSSatisfiesExpression":
+    case "TSTypeAssertion":
+    case "TSNonNullExpression":
+    case "TSInstantiationExpression":
+      return node.expression;
+    default:
+      return null;
+  }
+}
+function transformNode(node) {
+  if (isTypeOnlyStatement(node)) return REMOVE;
+  deleteTypeSyntaxFields(node);
+  if (node.type === "ImportDeclaration") {
+    node.specifiers = node.specifiers.filter(
+      (s) => !(s.importKind === "type" || s.importKind === "typeof")
     );
   } else if (node.type === "ExportNamedDeclaration") {
     if (node.specifiers) {
@@ -2616,483 +2959,158 @@ function substShape(s, map, cache, visiting) {
     case "brand":
       return { ...s, shape: substAbsInner(s.shape, map, cache, visiting) };
     case "eff":
-      return { ...s, inner: substAbsInner(s.inner, map, cache, visiting) };
-    case "arr":
-      return { ...s, element: substAbsInner(s.element, map, cache, visiting) };
-    case "tuple": {
-      const elements = s.elements.map(
-        (e) => substAbsInner(e, map, cache, visiting)
-      );
-      const next = { k: "tuple", elements };
-      if (s.rest) next.rest = substAbsInner(s.rest, map, cache, visiting);
-      return next;
-    }
-    case "fn": {
-      const next = { k: "fn", params: s.params };
-      if (s.name !== void 0) next.name = s.name;
-      if (s.paramTypes) {
-        next.paramTypes = s.paramTypes.map(
-          (p) => substAbsInner(p, map, cache, visiting)
-        );
-      }
-      if (s.returnType !== void 0) {
-        next.returnType = substAbsInner(s.returnType, map, cache, visiting);
-      }
-      return next;
-    }
-    case "sum":
-      return {
-        ...s,
-        members: s.members.map((m) => substAbsInner(m, map, cache, visiting))
-      };
-    case "obj": {
-      const slots = {};
-      for (const [k, slot] of Object.entries(s.slots)) {
-        const nextSlot = { value: substAbsInner(slot.value, map, cache, visiting) };
-        if (slot.optional) nextSlot.optional = true;
-        if (slot.readonly) nextSlot.readonly = true;
-        slots[k] = nextSlot;
-      }
-      const next = { k: "obj", slots };
-      if (s.index) {
-        next.index = {
-          key: substAbsInner(s.index.key, map, cache, visiting),
-          value: substAbsInner(s.index.value, map, cache, visiting)
-        };
-      }
-      if (s.open) next.open = true;
-      return next;
-    }
-  }
-}
-function substAbsInner(a, map, cache, visiting) {
-  if (a.term?.op === "var" && map.has(a.term.id)) {
-    const repl = map.get(a.term.id);
-    return {
-      shape: repl.shape,
-      term: repl.term,
-      pred: repl.pred,
-      conf: confJoin(a.conf, repl.conf)
-    };
-  }
-  const hit = cache.get(a);
-  if (hit !== void 0) return hit;
-  if (visiting.has(a)) return a;
-  visiting.add(a);
-  const shape = substShape(a.shape, map, cache, visiting);
-  const term = a.term ? substTermAbs(a.term, map) : void 0;
-  let pred = a.pred;
-  let conf = a.conf;
-  if (a.pred) {
-    const r = substPredAbs(a.pred, map);
-    pred = r.pred;
-    if (r.dropped) conf = confJoin(conf, "partial");
-  }
-  visiting.delete(a);
-  const result = abs(shape, term, pred, conf);
-  cache.set(a, result);
-  return result;
-}
-function substAbs(a, map) {
-  if (map.size === 0) return a;
-  return substAbsInner(a, map, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
-}
-function instantiateReturn(fn, args) {
-  const shape = fn.shape;
-  if (!shape || shape.k !== "fn") return unknown;
-  const src = getFnImpl(fn)?.relation ?? {
-    paramTypes: shape.paramTypes ?? [],
-    returnType: shape.returnType ?? unknown
-  };
-  const map = /* @__PURE__ */ new Map();
-  src.paramTypes.forEach((p, i) => {
-    if (p.term?.op !== "var") return;
-    const id = p.term.id;
-    if (map.has(id)) return;
-    map.set(id, args[i] ?? unknown);
-  });
-  return substAbs(src.returnType, map);
-}
-var applyCallbackHost;
-function setApplyCallbackHost(fn) {
-  applyCallbackHost = fn;
-}
-function applyCallbackAbs(cb, args, env, phi2, budget) {
-  if (!applyCallbackHost) {
-    if (cb && typeof cb === "object" && "shape" in cb) {
-      const a = cb;
-      const impl = getFnImpl(a);
-      if (impl?.relation) return instantiateReturn(a, args);
-      if (isRelFn(a)) return instantiateReturn(a, args);
-    }
-    return unknown;
-  }
-  return applyCallbackHost(cb, args, env, phi2, budget);
-}
-function undefAbs() {
-  return abs(
-    { k: "unknown" },
-    { op: "lit", value: void 0 },
-    pTrue,
-    "exact"
-  );
-}
-function mapElementFallback(cbAbs, elem, out) {
-  if (out.shape.k !== "unknown" || elem.term?.op !== "var") return out;
-  const slot = cbAbs?.shape.k === "fn" ? cbAbs.shape.returnType : void 0;
-  return slot ?? out;
-}
-function projectFlatMapResult(arrConf, mapped) {
-  const flatEls = [];
-  let anyUnknown = false;
-  for (const m of mapped) {
-    if (m.shape.k === "arr") flatEls.push(m.shape.element);
-    else if (m.shape.k === "tuple") flatEls.push(...m.shape.elements);
-    else anyUnknown = true;
-  }
-  if (anyUnknown || flatEls.length === 0) return unknown;
-  const first = flatEls[0];
-  const sameIdentity = flatEls.every((e) => {
-    if (e.shape.k !== first.shape.k) return false;
-    if (!e.term && !first.term) return true;
-    if (!e.term || !first.term) return false;
-    return termToString(e.term) === termToString(first.term);
-  });
-  const el = sameIdentity ? first : flatEls.reduce((a, b) => joinAbs(a, b));
-  return abs(
-    { k: "arr", element: el },
-    void 0,
-    void 0,
-    confJoin(arrConf, "path")
-  );
-}
-function asAbs(v2) {
-  if (v2 && typeof v2 === "object" && "shape" in v2) return v2;
-  return void 0;
-}
-
-// src/algebra/builtins.ts
-function numPrim(conf = "path") {
-  return abs({ k: "prim", type: "number" }, void 0, void 0, conf);
-}
-function strPrim(conf = "path") {
-  return abs({ k: "prim", type: "string" }, void 0, void 0, conf);
-}
-function boolPrim(conf = "partial") {
-  return abs({ k: "prim", type: "boolean" }, void 0, void 0, conf);
-}
-function evalMathMethod(name, args) {
-  const a0 = args[0] ? litValue(args[0]) : void 0;
-  const a1 = args[1] ? litValue(args[1]) : void 0;
-  switch (name) {
-    case "abs":
-      if (typeof a0 === "number") return numLit(Math.abs(a0));
-      return numPrim();
-    case "floor":
-      if (typeof a0 === "number") return numLit(Math.floor(a0));
-      return numPrim();
-    case "ceil":
-      if (typeof a0 === "number") return numLit(Math.ceil(a0));
-      return numPrim();
-    case "round":
-      if (typeof a0 === "number") return numLit(Math.round(a0));
-      return numPrim();
-    case "sqrt":
-      if (typeof a0 === "number") return numLit(Math.sqrt(a0));
-      return numPrim();
-    case "min": {
-      const lits = args.map(litValue);
-      if (lits.length > 0 && lits.every((x) => typeof x === "number")) {
-        return numLit(Math.min(...lits));
-      }
-      return numPrim();
-    }
-    case "max": {
-      const lits = args.map(litValue);
-      if (lits.length > 0 && lits.every((x) => typeof x === "number")) {
-        return numLit(Math.max(...lits));
-      }
-      return numPrim();
-    }
-    case "pow":
-      if (typeof a0 === "number" && typeof a1 === "number") return numLit(Math.pow(a0, a1));
-      return numPrim();
-    case "sign":
-      if (typeof a0 === "number") return numLit(Math.sign(a0));
-      return numPrim();
-    default:
-      return void 0;
-  }
-}
-function evalObjectMethod(name, args) {
-  const a0 = args[0];
-  switch (name) {
-    case "keys": {
-      if (a0?.shape.k === "obj") {
-        const keys = Object.keys(a0.shape.slots).map(
-          (k) => strLit(k)
+      return { ...s, inner: substAbsInner(s.inner, map, cache, visiting) };
+    case "arr":
+      return { ...s, element: substAbsInner(s.element, map, cache, visiting) };
+    case "tuple": {
+      const elements = s.elements.map(
+        (e) => substAbsInner(e, map, cache, visiting)
+      );
+      const next = { k: "tuple", elements };
+      if (s.rest) next.rest = substAbsInner(s.rest, map, cache, visiting);
+      return next;
+    }
+    case "fn": {
+      const next = { k: "fn", params: s.params };
+      if (s.name !== void 0) next.name = s.name;
+      if (s.paramTypes) {
+        next.paramTypes = s.paramTypes.map(
+          (p) => substAbsInner(p, map, cache, visiting)
         );
-        return abs({ k: "tuple", elements: keys }, void 0, void 0, "exact");
       }
-      return abs({ k: "arr", element: strPrim("path") }, void 0, void 0, "partial");
-    }
-    case "values": {
-      if (a0?.shape.k === "obj") {
-        const slots = a0.shape.slots;
-        const vals = Object.values(slots).map((s) => s.value);
-        return abs({ k: "tuple", elements: vals }, void 0, void 0, "exact");
+      if (s.returnType !== void 0) {
+        next.returnType = substAbsInner(s.returnType, map, cache, visiting);
       }
-      return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
+      return next;
     }
-    case "entries": {
-      if (a0?.shape.k === "obj") {
-        const slots = a0.shape.slots;
-        const entries = Object.entries(slots).map(
-          ([, s]) => abs({ k: "tuple", elements: [strPrim("exact"), s.value] }, void 0, void 0, "exact")
-        );
-        return abs({ k: "tuple", elements: entries }, void 0, void 0, "exact");
+    case "sum":
+      return {
+        ...s,
+        members: s.members.map((m) => substAbsInner(m, map, cache, visiting))
+      };
+    case "obj": {
+      const slots = {};
+      for (const [k, slot] of Object.entries(s.slots)) {
+        const nextSlot = { value: substAbsInner(slot.value, map, cache, visiting) };
+        if (slot.optional) nextSlot.optional = true;
+        if (slot.readonly) nextSlot.readonly = true;
+        slots[k] = nextSlot;
       }
-      return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
-    }
-    case "assign": {
-      if (!args.length) return unknown;
-      let acc = args[0];
-      for (let i = 1; i < args.length; i++) {
-        acc = { ...acc };
-        if (acc.shape.k === "obj" && args[i].shape.k === "obj") {
-          const base = acc.shape.slots;
-          const over = args[i].shape.slots;
-          acc = abs({ k: "obj", slots: { ...base, ...over } }, void 0, void 0, confJoin(acc.conf, args[i].conf));
-        }
+      const next = { k: "obj", slots };
+      if (s.index) {
+        next.index = {
+          key: substAbsInner(s.index.key, map, cache, visiting),
+          value: substAbsInner(s.index.value, map, cache, visiting)
+        };
       }
-      return acc;
+      if (s.open) next.open = true;
+      return next;
     }
-    default:
-      return void 0;
-  }
-}
-function evalJsonMethod(name, args) {
-  if (name === "stringify") return strPrim("partial");
-  if (name === "parse") return unknown;
-  return void 0;
-}
-function evalNumberStatic(name, args) {
-  const a0 = args[0] ? litValue(args[0]) : void 0;
-  switch (name) {
-    case "isInteger":
-      if (typeof a0 === "number") return boolLit(Number.isInteger(a0));
-      return boolPrim();
-    case "isNaN":
-      if (typeof a0 === "number") return boolLit(Number.isNaN(a0));
-      return boolPrim();
-    case "isFinite":
-      if (typeof a0 === "number") return boolLit(Number.isFinite(a0));
-      return boolPrim();
-    case "parseInt":
-    case "parseFloat":
-      if (typeof a0 === "string" || typeof a0 === "number") {
-        const n = name === "parseInt" ? parseInt(String(a0), 10) : parseFloat(String(a0));
-        return numLit(n);
-      }
-      return numPrim();
-    case "MAX_SAFE_INTEGER":
-      return numLit(Number.MAX_SAFE_INTEGER);
-    default:
-      return void 0;
-  }
-}
-function evalGlobalFn(name, args) {
-  const a0 = args[0] ? litValue(args[0]) : void 0;
-  switch (name) {
-    case "parseInt":
-      if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseInt(String(a0), 10));
-      return numPrim();
-    case "parseFloat":
-      if (typeof a0 === "string" || typeof a0 === "number") return numLit(parseFloat(String(a0)));
-      return numPrim();
-    case "isNaN":
-      if (typeof a0 === "number") return boolLit(Number.isNaN(a0));
-      return boolPrim();
-    case "Number":
-      if (typeof a0 === "number") return numLit(a0);
-      if (typeof a0 === "string") return numLit(Number(a0));
-      if (typeof a0 === "boolean") return numLit(a0 ? 1 : 0);
-      return numPrim();
-    case "String":
-      if (a0 !== void 0) return strLit(String(a0));
-      return strPrim();
-    case "Boolean":
-      if (a0 !== void 0) return boolLit(Boolean(a0));
-      return boolPrim();
-    default:
-      return void 0;
   }
 }
-function evalArrayStatic(name, args) {
-  const a0 = args[0];
-  switch (name) {
-    case "isArray": {
-      if (!a0) return boolLit(false);
-      const k = a0.shape.k;
-      return boolLit(k === "arr" || k === "tuple");
-    }
-    case "from":
-    case "of":
-      return abs({ k: "arr", element: a0 ?? unknown }, void 0, void 0, "path");
-    default:
-      return void 0;
+function substAbsInner(a, map, cache, visiting) {
+  if (a.term?.op === "var" && map.has(a.term.id)) {
+    const repl = map.get(a.term.id);
+    return {
+      shape: repl.shape,
+      term: repl.term,
+      pred: repl.pred,
+      conf: confJoin(a.conf, repl.conf)
+    };
   }
-}
-function evalDateCtor(args) {
-  return abs(
-    { k: "brand", name: "Date", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-    void 0,
-    void 0,
-    "path"
-  );
-}
-function evalDateStatic(name, _args) {
-  if (name === "now") return numLit(Date.now());
-  return void 0;
-}
-function evalDateMethod(name, _recv, _args) {
-  switch (name) {
-    case "getTime":
-    case "valueOf":
-      return numPrim("path");
-    case "toISOString":
-    case "toString":
-      return strPrim("path");
-    default:
-      return void 0;
+  const hit = cache.get(a);
+  if (hit !== void 0) return hit;
+  if (visiting.has(a)) return a;
+  visiting.add(a);
+  const shape = substShape(a.shape, map, cache, visiting);
+  const term = a.term ? substTermAbs(a.term, map) : void 0;
+  let pred = a.pred;
+  let conf = a.conf;
+  if (a.pred) {
+    const r = substPredAbs(a.pred, map);
+    pred = r.pred;
+    if (r.dropped) conf = confJoin(conf, "partial");
   }
+  visiting.delete(a);
+  const result = abs(shape, term, pred, conf);
+  cache.set(a, result);
+  return result;
 }
-function evalRegExpCtor(_args) {
-  return abs(
-    { k: "brand", name: "RegExp", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-    void 0,
-    void 0,
-    "path"
-  );
+function substAbs(a, map) {
+  if (map.size === 0) return a;
+  return substAbsInner(a, map, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
 }
-function evalRegExpMethod(name, _recv, _args) {
-  switch (name) {
-    case "test":
-      return boolPrim();
-    case "exec":
-      return unknown;
-    default:
-      return void 0;
-  }
+function instantiateReturn(fn, args) {
+  const shape = fn.shape;
+  if (!shape || shape.k !== "fn") return unknown;
+  const src = getFnImpl(fn)?.relation ?? {
+    paramTypes: shape.paramTypes ?? [],
+    returnType: shape.returnType ?? unknown
+  };
+  const map = /* @__PURE__ */ new Map();
+  src.paramTypes.forEach((p, i) => {
+    if (p.term?.op !== "var") return;
+    const id = p.term.id;
+    if (map.has(id)) return;
+    map.set(id, args[i] ?? unknown);
+  });
+  return substAbs(src.returnType, map);
 }
-function evalPromiseCtor(_args) {
-  return abs(
-    { k: "eff", eff: "promise", inner: unknown },
-    void 0,
-    void 0,
-    "partial"
-  );
+var applyCallbackHost;
+function setApplyCallbackHost(fn) {
+  applyCallbackHost = fn;
 }
-function evalPromiseStatic(name, args) {
-  switch (name) {
-    case "resolve": {
-      const inner = args[0] ?? unknown;
-      if (inner.shape.k === "eff" && inner.shape.eff === "promise") return inner;
-      return abs({ k: "eff", eff: "promise", inner }, void 0, void 0, "path");
-    }
-    case "reject":
-      return abs({ k: "eff", eff: "promise", inner: unknown }, void 0, void 0, "partial");
-    case "all": {
-      const a0 = args[0];
-      if (a0?.shape.k === "arr" && a0.shape.element.shape.k === "eff") {
-        return abs(
-          { k: "eff", eff: "promise", inner: abs({ k: "arr", element: a0.shape.element.shape.inner }, void 0, void 0, "path") },
-          void 0,
-          void 0,
-          "path"
-        );
-      }
-      return abs({ k: "eff", eff: "promise", inner: abs({ k: "arr", element: unknown }, void 0, void 0, "partial") }, void 0, void 0, "partial");
+function applyCallbackAbs(cb, args, env, phi2, budget) {
+  if (!applyCallbackHost) {
+    if (cb && typeof cb === "object" && "shape" in cb) {
+      const a = cb;
+      const impl = getFnImpl(a);
+      if (impl?.relation) return instantiateReturn(a, args);
+      if (isRelFn(a)) return instantiateReturn(a, args);
     }
-    default:
-      return void 0;
+    return unknown;
   }
+  return applyCallbackHost(cb, args, env, phi2, budget);
 }
-function evalNamespaceCall(ns, method, args) {
-  switch (ns) {
-    case "Math":
-      return evalMathMethod(method, args);
-    case "Object":
-      return evalObjectMethod(method, args);
-    case "JSON":
-      return evalJsonMethod(method, args);
-    case "Number":
-      return evalNumberStatic(method, args);
-    case "Array":
-      return evalArrayStatic(method, args);
-    case "Date":
-      return evalDateStatic(method, args);
-    case "Promise":
-      return evalPromiseStatic(method, args);
-    default:
-      return void 0;
-  }
+function undefAbs() {
+  return abs(
+    { k: "unknown" },
+    { op: "lit", value: void 0 },
+    pTrue,
+    "exact"
+  );
 }
-function evalBuiltinNew(className, args) {
-  switch (className) {
-    case "Date":
-      return evalDateCtor(args);
-    case "RegExp":
-      return evalRegExpCtor(args);
-    case "Promise":
-      return evalPromiseCtor(args);
-    case "Map":
-      return abs(
-        { k: "brand", name: "Map", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-        void 0,
-        void 0,
-        "path"
-      );
-    case "Set":
-      return abs(
-        { k: "brand", name: "Set", shape: abs({ k: "obj", slots: {} }, void 0, void 0, "exact") },
-        void 0,
-        void 0,
-        "path"
-      );
-    default:
-      return void 0;
-  }
+function mapElementFallback(cbAbs, elem, out) {
+  if (out.shape.k !== "unknown" || elem.term?.op !== "var") return out;
+  const slot = cbAbs?.shape.k === "fn" ? cbAbs.shape.returnType : void 0;
+  return slot ?? out;
 }
-function evalBuiltinInstanceMethod(brandName, method, recv, args) {
-  if (brandName === "Date") return evalDateMethod(method, recv, args);
-  if (brandName === "RegExp") return evalRegExpMethod(method, recv, args);
-  if (brandName === "Map") {
-    switch (method) {
-      case "get":
-        return unknown;
-      case "has":
-        return boolPrim();
-      case "set":
-        return recv;
-      case "size":
-        return numPrim("path");
-      default:
-        return void 0;
-    }
-  }
-  if (brandName === "Set") {
-    switch (method) {
-      case "has":
-        return boolPrim();
-      case "add":
-        return recv;
-      case "size":
-        return numPrim("path");
-      default:
-        return void 0;
-    }
+function projectFlatMapResult(arrConf, mapped) {
+  const flatEls = [];
+  let anyUnknown = false;
+  for (const m of mapped) {
+    if (m.shape.k === "arr") flatEls.push(m.shape.element);
+    else if (m.shape.k === "tuple") flatEls.push(...m.shape.elements);
+    else anyUnknown = true;
   }
+  if (anyUnknown || flatEls.length === 0) return unknown;
+  const first = flatEls[0];
+  const sameIdentity = flatEls.every((e) => {
+    if (e.shape.k !== first.shape.k) return false;
+    if (!e.term && !first.term) return true;
+    if (!e.term || !first.term) return false;
+    return termToString(e.term) === termToString(first.term);
+  });
+  const el = sameIdentity ? first : flatEls.reduce((a, b) => joinAbs(a, b));
+  return abs(
+    { k: "arr", element: el },
+    void 0,
+    void 0,
+    confJoin(arrConf, "path")
+  );
+}
+function asAbs(v2) {
+  if (v2 && typeof v2 === "object" && "shape" in v2) return v2;
   return void 0;
 }
 
@@ -4661,6 +4679,7 @@ function evalVarDecl(node, env, phi2, budget) {
   for (const d of node.declarations) {
     if (d.id.type !== "Identifier" || !d.init) continue;
     const r = evalNode(d.init, local, phi2, budget);
+    recordAbsNode(d.id, r.value);
     local = withVar(local, d.id.name, r.value);
   }
   return { value: unknown, phi: phi2, env: local };
@@ -4814,6 +4833,15 @@ function $call(fn, args) {
 
 // src/algebra/exec/calls.ts
 var bCallCollector = null;
+var GLOBAL_FNS = /* @__PURE__ */ new Set([
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "Number",
+  "String",
+  "Boolean"
+]);
 function setBCallCollector(collector) {
   bCallCollector = collector;
 }
@@ -4832,7 +4860,8 @@ function $callNamed(name, fn, args, loc, argLocs) {
   if (loc) pushCallLoc({ line: loc[0], column: loc[1] });
   try {
     if (typeof fn === "function") {
-      result = fn(...args);
+      const g = GLOBAL_FNS.has(name) && fn === globalThis[name] ? evalGlobalFn(name, args) : void 0;
+      result = g ?? fn(...args);
     } else if (fn && typeof fn === "object" && "shape" in fn) {
       result = $call(fn, args);
     }
@@ -4955,12 +4984,32 @@ function litAbsFromJs(v2) {
   }
   return unknown;
 }
+function litTruth(a) {
+  if (a.term?.op === "lit") {
+    return Boolean(a.term.value);
+  }
+  switch (a.shape.k) {
+    case "obj":
+    case "arr":
+    case "tuple":
+    case "fn":
+    case "brand":
+    case "eff":
+      return true;
+    case "prim":
+      return a.shape.type === "symbol" || a.shape.type === "bigint" ? true : void 0;
+    case "never":
+      return false;
+    default:
+      return void 0;
+  }
+}
 function isDefinitelyTrue(a) {
-  return litValue(a) === true;
+  return litTruth(a) === true;
 }
 function isDefinitelyFalse(a) {
-  const lv = litValue(a);
-  if (lv === false) return true;
+  const t = litTruth(a);
+  if (t === false) return true;
   if (a.shape.k === "never") return true;
   return false;
 }
@@ -5031,17 +5080,31 @@ function $idx(a, i) {
   if (a.shape.k === "sum") {
     return a.shape.members.map((m) => $idx(m, i)).reduce((x, y) => joinAbs(x, y));
   }
+  const sv = litValue(a);
+  if (typeof sv === "string") {
+    if (typeof iv === "number" && Number.isInteger(iv)) {
+      if (iv >= 0 && iv < sv.length) {
+        return abs(
+          { k: "prim", type: "string" },
+          { op: "lit", value: sv[iv] },
+          pTrue,
+          "exact"
+        );
+      }
+      return undef();
+    }
+    return unknown;
+  }
   return unknown;
 }
 function $idxSet(a, i, value) {
   const iv = litValue(i);
-  if (a.shape.k === "tuple" && typeof iv === "number" && Number.isInteger(iv)) {
+  if (a.shape.k === "tuple" && typeof iv === "number" && Number.isInteger(iv) && iv >= 0) {
     const els = [...a.shape.elements];
-    if (iv >= 0 && iv < els.length) {
-      els[iv] = asAbsVal(value);
-      const next = abs({ k: "tuple", elements: els }, void 0, void 0, a.conf);
-      return next;
-    }
+    while (els.length < iv) els.push(undef());
+    els[iv] = asAbsVal(value);
+    const next = abs({ k: "tuple", elements: els }, void 0, void 0, a.conf);
+    return next;
   }
   return a;
 }
@@ -5057,6 +5120,15 @@ function $len(a) {
   if (a.shape.k === "arr") {
     return abs({ k: "prim", type: "number" }, void 0, void 0, "path");
   }
+  const sv = litValue(a);
+  if (typeof sv === "string") {
+    return abs(
+      { k: "prim", type: "number" },
+      { op: "lit", value: sv.length },
+      pTrue,
+      "exact"
+    );
+  }
   return unknown;
 }
 function $obj(slots) {
@@ -5116,7 +5188,52 @@ function $forOf(iterable, body, maxIters = DEFAULT_MAX_LOOP_ITERS) {
     ));
   }
 }
+function namespaceNameOf(v2) {
+  if (typeof v2 !== "object" && typeof v2 !== "function") return void 0;
+  if (v2 === Math) return "Math";
+  if (v2 === Number) return "Number";
+  if (v2 === JSON) return "JSON";
+  if (v2 === Object) return "Object";
+  if (v2 === Array) return "Array";
+  if (v2 === Date) return "Date";
+  if (v2 === Promise) return "Promise";
+  return void 0;
+}
+function $regex(pattern, flags = "") {
+  const litStr = (v2) => abs({ k: "prim", type: "string" }, { op: "lit", value: v2 }, pTrue, "exact");
+  return abs(
+    {
+      k: "brand",
+      name: "RegExp",
+      shape: objOf({
+        source: { value: litStr(pattern) },
+        flags: { value: litStr(flags) }
+      })
+    },
+    void 0,
+    void 0,
+    "exact"
+  );
+}
 function $get(o, key, opts) {
+  if (!o || typeof o !== "object" || !("shape" in o)) {
+    const ns = namespaceNameOf(o);
+    if (ns) {
+      try {
+        const raw = o[key];
+        if (typeof raw === "function") {
+          return absFunction([`${ns}.${key}`], {
+            body: noBody,
+            apply: (args) => evalNamespaceCall(ns, key, args) ?? unknown
+          });
+        }
+        return $lit(raw);
+      } catch {
+        return unknown;
+      }
+    }
+    return unknown;
+  }
   if (o.shape.k === "brand") return $get(o.shape.shape, key, opts);
   if (isObj(o)) {
     const slot = o.shape.slots[key];
@@ -5302,6 +5419,77 @@ var BIN_OPS = {
   "===": "$eq",
   "!==": "$ne"
 };
+var COMPOUND_OPS = {
+  "+=": "$add",
+  "-=": "$sub",
+  "*=": "$mul",
+  "/=": "$div",
+  "%=": "$mod"
+};
+function memberPathOf(m, opts) {
+  const layers = [];
+  let cur = m;
+  let rootSrc = null;
+  while (cur.type === "MemberExpression") {
+    const mm = cur;
+    const k = mm.property;
+    if (mm.computed) {
+      if (k.type === "NumericLiteral") {
+        const key = `$lit(${k.value})`;
+        layers.unshift({
+          get: (b) => `$idx(${b}, ${key})`,
+          set: (b, v2) => `$idxSet(${b}, ${key}, ${v2})`
+        });
+      } else if (k.type === "StringLiteral") {
+        const key = JSON.stringify(k.value);
+        layers.unshift({
+          get: (b) => `$get(${b}, ${key})`,
+          set: (b, v2) => `$set(${b}, ${key}, ${v2})`
+        });
+      } else if (isExpression(k)) {
+        const key = transpileExpression(k, opts);
+        layers.unshift({
+          get: (b) => `$idx(${b}, ${key})`,
+          set: (b, v2) => `$idxSet(${b}, ${key}, ${v2})`
+        });
+      } else {
+        return null;
+      }
+    } else if (k.type === "Identifier") {
+      const key = JSON.stringify(k.name);
+      layers.unshift({
+        get: (b) => `$get(${b}, ${key})`,
+        set: (b, v2) => `$set(${b}, ${key}, ${v2})`
+      });
+    } else {
+      return null;
+    }
+    cur = mm.object;
+  }
+  if (cur.type === "Identifier") {
+    rootSrc = cur.name;
+  } else if (cur.type === "ThisExpression" && opts.thisParam) {
+    rootSrc = opts.thisParam;
+  } else {
+    return null;
+  }
+  return { rootSrc, layers };
+}
+function readPathSrc(p) {
+  return p.layers.reduce((acc, l) => l.get(acc), p.rootSrc);
+}
+function setPathSrc(p, valSrc) {
+  let acc = valSrc;
+  for (let i = p.layers.length - 1; i >= 0; i--) {
+    const l = p.layers[i];
+    const base = i === 0 ? p.rootSrc : readPrefix(p, i - 1);
+    acc = l.set(base, acc);
+  }
+  return acc;
+}
+function readPrefix(p, j) {
+  return p.layers.slice(0, j + 1).reduce((acc, l) => l.get(acc), p.rootSrc);
+}
 function transpileSource(source, opts = {}) {
   const file = parseSource(source);
   return transpileFile(file, { ...opts, source: opts.source ?? source });
@@ -5310,7 +5498,7 @@ function transpileFile(file, opts = {}) {
   const runtime = opts.runtimeImport ?? "@nudojs/core/exec";
   const lines = [
     `// nudo B-path transpile \u2014 values are Abs; operators are overloaded calls`,
-    `import { $add, $sub, $mul, $div, $mod, $neg, $typeof, $not, $eq, $ne, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $while, $whileSeq, $arr, $idx, $idxSet, $len, $call, $throw, $class, $new, $invoke, $invokeSuper, $super, $async, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal } from ${JSON.stringify(runtime)};`,
+    `import { $add, $sub, $mul, $div, $mod, $neg, $typeof, $not, $eq, $ne, $lt, $le, $gt, $ge, $join, $lit, $fork, $for, $forIter, $obj, $get, $set, $while, $whileSeq, $arr, $idx, $idxSet, $len, $call, $throw, $class, $new, $invoke, $invokeSuper, $super, $async, $await, $asyncReturn, $orDefault, $callNamed, $optionalGet, $optionalInvoke, $spread, $concat, $forOf, $catchVal, $switch, $staticInvoke, $setKey, $gen, $yield, $fnVal, $regex } from ${JSON.stringify(runtime)};`,
     ``
   ];
   for (const stmt of file.program.body) {
@@ -5329,34 +5517,24 @@ function stmtReturns(stmt) {
   }
   return false;
 }
-function stmtAlwaysExits(stmt) {
-  return stmtReturns(stmt) && stmt.type !== "ExpressionStatement";
-}
-function foldEarlyReturns(stmts) {
-  for (let i = stmts.length - 2; i >= 0; i--) {
+function transpileFnBodyStmts(stmts, depth, opts) {
+  for (let i = 0; i < stmts.length; i++) {
     const stmt = stmts[i];
     if (stmt.type !== "IfStatement" || stmt.alternate != null) continue;
     if (!stmtReturns(stmt.consequent)) continue;
-    const tail = stmts.slice(i + 1);
-    if (tail.length === 0 || !tail.every(stmtAlwaysExits)) continue;
-    const alt = {
-      type: "BlockStatement",
-      body: tail,
-      directives: [],
-      start: stmt.consequent.start,
-      end: stmt.consequent.end,
-      loc: stmt.consequent.loc
-    };
-    const rewritten = {
-      ...stmt,
-      alternate: alt
-    };
-    return foldEarlyReturns([...stmts.slice(0, i), rewritten]);
-  }
-  return stmts;
-}
-function transpileFnBodyStmts(stmts, depth, opts) {
-  return foldEarlyReturns(stmts).map((s) => transpileStatement(s, depth, opts)).join("\n");
+    const rest = stmts.slice(i + 1);
+    if (rest.length === 0) continue;
+    const head = stmts.slice(0, i).map((s) => transpileStatement(s, depth, opts)).join("\n");
+    const test = transpileExpression(stmt.test, opts);
+    const cons = transpileBlockAsThunk(stmt.consequent, depth, opts);
+    const altBody = transpileFnBodyStmts(rest, depth + 1, opts);
+    const promoted = `${indent(depth)}return $fork(${test}, ${cons}, () => {
+${altBody}
+${indent(depth)}});`;
+    return head ? `${head}
+${promoted}` : promoted;
+  }
+  return stmts.map((s) => transpileStatement(s, depth, opts)).join("\n");
 }
 function emitDestructure(pattern, fromSrc, kw, pad, opts, out, tmpSeq) {
   if (pattern.type === "Identifier") {
@@ -5422,13 +5600,55 @@ function emitDestructure(pattern, fromSrc, kw, pad, opts, out, tmpSeq) {
     });
   }
 }
+function emitParamBinding(params, pad, opts) {
+  const sig = [];
+  const prologue = [];
+  let rest;
+  params.forEach((p, i) => {
+    if (p.type === "Identifier") {
+      sig.push(p.name);
+      return;
+    }
+    if (p.type === "RestElement") {
+      if (p.argument.type === "Identifier") {
+        rest = p.argument.name;
+        return;
+      }
+      const ph2 = `_rest${i}`;
+      rest = ph2;
+      emitDestructure(p.argument, ph2, "const", pad, opts, prologue, { n: 0 });
+      return;
+    }
+    const ph = `_p${i}`;
+    sig.push(ph);
+    if (p.type === "AssignmentPattern") {
+      const def = transpileExpression(p.right, opts);
+      if (p.left.type === "Identifier") {
+        prologue.push(`${pad}const ${p.left.name} = $orDefault(${ph}, () => ${def});`);
+      } else {
+        const t = `_pd${i}`;
+        prologue.push(`${pad}const ${t} = $orDefault(${ph}, () => ${def});`);
+        emitDestructure(p.left, t, "const", pad, opts, prologue, { n: 0 });
+      }
+      return;
+    }
+    if (p.type === "ObjectPattern" || p.type === "ArrayPattern") {
+      emitDestructure(p, ph, "const", pad, opts, prologue, { n: 0 });
+    }
+  });
+  return { sig, rest, prologue };
+}
 function transpileStatement(stmt, depth, opts) {
   const pad = indent(depth);
   switch (stmt.type) {
     case "ExportNamedDeclaration": {
       const decl = stmt.declaration;
       if (!decl) return `${pad}/* export specifiers skipped */`;
-      return transpileStatement(decl, depth, opts);
+      const inner = transpileStatement(decl, depth, opts);
+      if (depth === 0 && decl.type === "VariableDeclaration" && !pad) {
+        return `export ${inner}`;
+      }
+      return inner;
     }
     case "ImportDeclaration": {
       const specs = stmt.specifiers.map((s) => {
@@ -5455,19 +5675,16 @@ function transpileStatement(stmt, depth, opts) {
     }
     case "FunctionDeclaration": {
       if (!stmt.id) return `${pad}// <anonymous fn skipped>`;
-      const paramParts = stmt.params.map((p) => {
-        if (p.type === "Identifier") return { kind: "id", name: p.name };
-        if (p.type === "RestElement" && p.argument.type === "Identifier") {
-          return { kind: "rest", name: p.argument.name };
-        }
-        return { kind: "id", name: "_" };
-      });
-      const named = paramParts.filter((p) => p.kind === "id" && p.name !== "_").map((p) => p.name);
-      const rest = paramParts.find((p) => p.kind === "rest");
-      const paramsSig = rest ? [...named, `...${rest.name}`] : named;
+      const { sig, rest, prologue } = emitParamBinding(
+        stmt.params,
+        indent(depth + 2),
+        opts
+      );
+      const named = sig;
+      const paramsSig = rest ? [...named, `...${rest}`] : named;
       const params = paramsSig.join(", ");
-      const bodyStmts = stmt.body.type === "BlockStatement" ? transpileFnBodyStmts(stmt.body.body, depth + 2, opts) : `${indent(depth + 2)}return ${transpileExpression(stmt.body, opts)};`;
-      const restBind = rest ? `${indent(depth + 1)}const ${rest.name} = arguments.length > ${named.length} ? $arr(Array.from(arguments).slice(${named.length})) : $arr([]);
+      const bodyStmts = stmt.body.type === "BlockStatement" ? [...prologue, transpileFnBodyStmts(stmt.body.body, depth + 2, opts)].join("\n") : `${indent(depth + 2)}return ${transpileExpression(stmt.body, opts)};`;
+      const restBind = rest ? `${indent(depth + 1)}const ${rest} = arguments.length > ${named.length} ? $arr(Array.from(arguments).slice(${named.length})) : $arr([]);
 ` : "";
       if (stmt.generator) {
         return [
@@ -5509,7 +5726,7 @@ function transpileStatement(stmt, depth, opts) {
     case "ExpressionStatement":
       return `${pad}${transpileExpression(stmt.expression, opts)};`;
     case "VariableDeclaration": {
-      const kw = stmt.kind === "const" ? "const" : "let";
+      const kw = "let";
       const asVar = matchAsOverride(stmt, opts);
       const lines = [];
       let tmpSeq = 0;
@@ -5562,7 +5779,7 @@ function transpileStatement(stmt, depth, opts) {
       ].join("\n");
     }
     case "BlockStatement":
-      return stmt.body.map((s) => transpileStatement(s, depth, opts)).join("\n");
+      return transpileFnBodyStmts(stmt.body, depth, opts);
     case "SwitchStatement": {
       const disc = transpileExpression(stmt.discriminant, opts);
       const arms = [];
@@ -5822,6 +6039,15 @@ function transpileExpression(expr, opts = {}) {
       const r = transpileExpression(expr.right, opts);
       return op === "&&" ? `$fork(${l}, () => ${r}, () => ${l})` : `$fork(${l}, () => ${l}, () => ${r})`;
     }
+    case "ConditionalExpression": {
+      const test = transpileExpression(expr.test, opts);
+      const c = transpileExpression(expr.consequent, opts);
+      const a = transpileExpression(expr.alternate, opts);
+      return `$fork(${test}, () => ${c}, () => ${a})`;
+    }
+    case "RegExpLiteral": {
+      return `$regex(${JSON.stringify(expr.pattern)}${expr.flags ? `, ${JSON.stringify(expr.flags)}` : ""})`;
+    }
     case "BinaryExpression": {
       const fn = BIN_OPS[expr.operator];
       if (!fn) return `/* unsupported ${expr.operator} */ $lit(undefined)`;
@@ -5837,6 +6063,14 @@ function transpileExpression(expr, opts = {}) {
       if (expr.operator === "+") return arg;
       return `/* unary ${expr.operator} */ $lit(undefined)`;
     }
+    case "UpdateExpression": {
+      const arg = expr.argument;
+      if (arg.type === "Identifier") {
+        const fn = expr.operator === "++" ? "$add" : "$sub";
+        return `${arg.name} = ${fn}(${arg.name}, $lit(1))`;
+      }
+      return `/* update ${expr.operator} */ $lit(undefined)`;
+    }
     case "AwaitExpression": {
       const arg = transpileExpression(expr.argument, opts);
       return `$await(${arg})`;
@@ -5938,19 +6172,23 @@ function transpileExpression(expr, opts = {}) {
       return acc ?? `$arr([])`;
     }
     case "AssignmentExpression": {
-      if (expr.operator !== "=") return `/* assign ${expr.operator} */ $lit(undefined)`;
+      const compoundFn = COMPOUND_OPS[expr.operator];
       const right = transpileExpression(expr.right, opts);
       if (expr.left.type === "MemberExpression") {
-        if (!expr.left.computed && expr.left.object.type === "ThisExpression" && expr.left.property.type === "Identifier" && opts.thisParam) {
-          return `${opts.thisParam} = $set(${opts.thisParam}, ${JSON.stringify(expr.left.property.name)}, ${right})`;
+        const m = expr.left;
+        const path = memberPathOf(m, opts);
+        if (path) {
+          const valSrc = compoundFn ? `${compoundFn}(${readPathSrc(path)}, ${right})` : right;
+          const writeSrc = setPathSrc(path, valSrc);
+          return `${path.rootSrc} = ${writeSrc}`;
         }
-        if (!expr.left.computed && expr.left.property.type === "Identifier") {
-          const obj2 = transpileExpression(expr.left.object, opts);
-          return `$set(${obj2}, ${JSON.stringify(expr.left.property.name)}, ${right})`;
+        if (!m.computed && m.property.type === "Identifier") {
+          const obj2 = transpileExpression(m.object, opts);
+          return `$set(${obj2}, ${JSON.stringify(m.property.name)}, ${right})`;
         }
-        if (expr.left.computed) {
-          const obj2 = transpileExpression(expr.left.object, opts);
-          const k = expr.left.property;
+        if (m.computed) {
+          const obj2 = transpileExpression(m.object, opts);
+          const k = m.property;
           if (k.type === "NumericLiteral") {
             return `$idxSet(${obj2}, $lit(${k.value}), ${right})`;
           }
@@ -5961,11 +6199,15 @@ function transpileExpression(expr, opts = {}) {
             return `$idxSet(${obj2}, ${transpileExpression(k, opts)}, ${right})`;
           }
         }
+        return `/* assign */ $lit(undefined)`;
       }
       if (expr.left.type === "Identifier") {
+        if (compoundFn) {
+          return `${expr.left.name} = ${compoundFn}(${expr.left.name}, ${right})`;
+        }
         return `${expr.left.name} = ${right}`;
       }
-      return `/* assign */ $lit(undefined)`;
+      return compoundFn ? `/* assign ${expr.operator} */ $lit(undefined)` : `/* assign */ $lit(undefined)`;
     }
     case "CallExpression":
     case "OptionalCallExpression": {
@@ -6020,16 +6262,11 @@ function transpileExpression(expr, opts = {}) {
     case "ArrowFunctionExpression":
     case "FunctionExpression": {
       const fn = expr;
-      const paramParts = fn.params.map((p) => {
-        if (p.type === "Identifier") return p.name;
-        if (p.type === "RestElement" && p.argument?.type === "Identifier") {
-          return `...${p.argument.name}`;
-        }
-        return "_p";
-      });
-      const nameList = `[${paramParts.map((p) => JSON.stringify(p.startsWith("...") ? p.slice(3) : p)).join(", ")}]`;
+      const { sig, rest, prologue } = emitParamBinding(fn.params, indent(1), opts);
+      const paramParts = rest ? [...sig, `...${rest}`] : sig;
+      const nameList = `[${sig.map((p) => JSON.stringify(p)).join(", ")}]`;
       if (fn.body.type === "BlockStatement") {
-        const inner = transpileFnBodyStmts(fn.body.body, 1, opts);
+        const inner = [...prologue, transpileFnBodyStmts(fn.body.body, 1, opts)].join("\n");
         if (fn.async) {
           return `$fnVal(${nameList}, (${paramParts.join(", ")}) => $async(() => {
 ${inner}
@@ -6040,6 +6277,13 @@ ${inner}
 })`;
       }
       const bodySrc = transpileExpression(fn.body, opts);
+      if (prologue.length > 0) {
+        const thunk = fn.async ? `$async(() => ${bodySrc})` : bodySrc;
+        return `$fnVal(${nameList}, (${paramParts.join(", ")}) => {
+${prologue.join("\n")}
+  return ${thunk};
+})`;
+      }
       if (fn.async) {
         return `$fnVal(${nameList}, (${paramParts.join(", ")}) => $async(() => ${bodySrc}))`;
       }
@@ -6128,6 +6372,21 @@ function findCtor(startName) {
 }
 function $new(cls, args) {
   if (typeof cls === "function") {
+    if (cls === Array) {
+      if (args.length === 1) {
+        const n = litValue(args[0]);
+        if (typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= 4096) {
+          const els = Array.from({ length: n }, () => undefAbs());
+          return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
+        }
+        return abs({ k: "arr", element: unknown }, void 0, void 0, "partial");
+      }
+      return abs({ k: "tuple", elements: args.map((a) => asAbs(a) ?? unknown) }, void 0, void 0, "exact");
+    }
+    if (cls === RegExp) {
+      const p = args[0] ? litValue(args[0]) : void 0;
+      if (typeof p === "string") return $regex(p, args[1] ? String(litValue(args[1]) ?? "") : "");
+    }
     const name = cls.name || "Object";
     const shape = objOf({});
     return abs({ k: "brand", name, shape }, void 0, void 0, "path");
@@ -6168,12 +6427,82 @@ function $super(thisVal, childName, args) {
   }
   return after ?? thisVal;
 }
+function execRegexBrand(re, method, args) {
+  if (re.shape.k !== "brand" || re.shape.name !== "RegExp") return void 0;
+  if (method !== "exec" && method !== "test" && method !== "toString") return void 0;
+  const inner = re.shape.shape;
+  const patAbs = inner.shape.k === "obj" ? inner.shape.slots["source"]?.value : void 0;
+  const flagsAbs = inner.shape.k === "obj" ? inner.shape.slots["flags"]?.value : void 0;
+  const pat = patAbs ? litValue(patAbs) : void 0;
+  if (typeof pat !== "string") return void 0;
+  const flagsV = flagsAbs ? litValue(flagsAbs) : void 0;
+  const flags = typeof flagsV === "string" ? flagsV : "";
+  if (method === "toString") return strLit(`/${pat}/${flags}`);
+  const subject = args[0] ? litValue(args[0]) : void 0;
+  if (typeof subject !== "string") {
+    return method === "test" ? abs({ k: "prim", type: "boolean" }, void 0, void 0, "partial") : void 0;
+  }
+  let reReal;
+  try {
+    reReal = new RegExp(pat, flags);
+  } catch {
+    return void 0;
+  }
+  const m = reReal.exec(subject);
+  if (method === "test") return boolLit(reReal.test(subject));
+  if (!m) {
+    return abs({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
+  }
+  const els = m.map((g) => g === void 0 ? undefAbs() : strLit(g));
+  return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
+}
+function stringRegexMethod(recv, method, args) {
+  if (method !== "match" && method !== "search") return void 0;
+  const re = args[0];
+  if (!re || re.shape.k !== "brand" || re.shape.name !== "RegExp") return void 0;
+  const inner = re.shape.shape;
+  const patAbs = inner.shape.k === "obj" ? inner.shape.slots["source"]?.value : void 0;
+  const flagsAbs = inner.shape.k === "obj" ? inner.shape.slots["flags"]?.value : void 0;
+  const pat = patAbs ? litValue(patAbs) : void 0;
+  const sv = litValue(recv);
+  if (typeof pat !== "string" || typeof sv !== "string") return void 0;
+  const flagsV = flagsAbs ? litValue(flagsAbs) : void 0;
+  const flags = typeof flagsV === "string" ? flagsV : "";
+  let reReal;
+  try {
+    reReal = new RegExp(pat, flags);
+  } catch {
+    return void 0;
+  }
+  if (method === "search") {
+    const idx = sv.search(reReal);
+    return abs({ k: "prim", type: "number" }, { op: "lit", value: idx }, void 0, "exact");
+  }
+  if (flags.includes("g")) {
+    const all = sv.match(reReal) ?? [];
+    return abs({ k: "tuple", elements: all.map((s) => strLit(s)) }, void 0, void 0, "exact");
+  }
+  const m = reReal.exec(sv);
+  if (!m) {
+    return abs({ k: "unknown" }, { op: "lit", value: null }, void 0, "exact");
+  }
+  const els = m.map((g) => g === void 0 ? undefAbs() : strLit(g));
+  return abs({ k: "tuple", elements: els }, void 0, void 0, "exact");
+}
 function $invoke(thisVal, method, args, loc) {
+  if (!thisVal || typeof thisVal !== "object" || !("shape" in thisVal)) {
+    const ns = namespaceNameOf(thisVal);
+    return (ns ? evalNamespaceCall(ns, method, args) : void 0) ?? unknown;
+  }
   if (thisVal.shape.k === "sum") {
     const results = thisVal.shape.members.filter((m) => memberLikelyHasMethod(m, method)).map((m) => $invoke(m, method, args, loc));
     if (results.length === 0) return unknown;
     return results.reduce((a, b) => joinAbs(a, b));
   }
+  {
+    const reR = execRegexBrand(thisVal, method, args);
+    if (reR !== void 0) return reR;
+  }
   const brandName = thisVal.shape.k === "brand" ? thisVal.shape.name : void 0;
   if (brandName) {
     const m = findMethod(brandName, method);
@@ -6186,6 +6515,10 @@ function $invoke(thisVal, method, args, loc) {
     const arrR = invokeArrMethod(thisVal, method, args);
     if (arrR !== void 0) return arrR;
   }
+  {
+    const sm = stringRegexMethod(thisVal, method, args);
+    if (sm !== void 0) return sm;
+  }
   {
     const viaTable = callAbsMethod(thisVal, method, args);
     if (viaTable) return viaTable;
@@ -6280,6 +6613,18 @@ function invokeArrMethod(arr, method, args) {
   if (method === "join") {
     return abs({ k: "prim", type: "string" }, void 0, void 0, "path");
   }
+  if (method === "fill" && args.length >= 1) {
+    const v2 = asAbs(args[0]) ?? unknown;
+    if (shape.k === "tuple") {
+      return abs(
+        { k: "tuple", elements: shape.elements.map(() => v2) },
+        void 0,
+        void 0,
+        confJoin(arr.conf, v2.conf)
+      );
+    }
+    return abs({ k: "arr", element: v2 }, void 0, void 0, confJoin(arr.conf, v2.conf));
+  }
   if (method === "includes") {
     return abs({ k: "prim", type: "boolean" }, void 0, void 0, "partial");
   }
@@ -6328,6 +6673,7 @@ function $thisSet(thisVal, key, value) {
   return unknown;
 }
 function $orDefault(v2, dflt) {
+  if (v2 === void 0) return asAbsVal(dflt());
   if (litValue(v2) === void 0 && v2.shape.k !== "never") {
     if (v2.term?.op === "lit" && v2.term.value === void 0) return asAbsVal(dflt());
     if (v2.shape.k === "unknown" && v2.term?.op === "lit") return asAbsVal(dflt());
@@ -6382,7 +6728,7 @@ var RUNTIME_IMPORT_RE = /^import\s*\{[^}]+\}\s*from\s*"[^"]+";\s*$/m;
 function rewriteUserImports(js) {
   js = js.replace(
     /^import\s*\{\s*\*\s+as\s+([A-Za-z_$][\w$]*)\s*\}\s*from\s*["']([^"']+)["'];\s*$/gm,
-    (_all, local, spec) => `const ${local} = __nudoBindNamespace(${JSON.stringify(spec)});`
+    (_all, local, spec) => `let ${local} = __nudoBindNamespace(${JSON.stringify(spec)});`
   );
   js = js.replace(
     /^import\s*["']([^"']+)["'];\s*$/gm,
@@ -6395,7 +6741,7 @@ function rewriteUserImports(js) {
       return parts.map((p) => {
         const [imported, local] = p.split(/\s+as\s+/).map((x) => x.trim());
         const bind = local ?? imported;
-        return `const ${bind} = __nudoBindImport(${JSON.stringify(spec)}, ${JSON.stringify(imported)});`;
+        return `let ${bind} = __nudoBindImport(${JSON.stringify(spec)}, ${JSON.stringify(imported)});`;
       }).join("\n");
     }
   );
@@ -6540,8 +6886,8 @@ ${js}`;
   }
   const exportFns = [...js.matchAll(/^export function (\w+)/gm)].map((m) => m[1]);
   js = js.replace(/^export function /gm, "function ");
-  const exportConsts = [...js.matchAll(/^export const (\w+)/gm)].map((m) => m[1]);
-  js = js.replace(/^export const /gm, "const ");
+  const exportConsts = [...js.matchAll(/^export (?:const|let) (\w+)/gm)].map((m) => m[1]);
+  js = js.replace(/^export (?:const|let) /gm, "let ");
   const names = [.../* @__PURE__ */ new Set([...exportFns, ...exportConsts])];
   const argNames = [
     ...runtimeArgNames(),
@@ -6595,6 +6941,17 @@ function callTranspiledExportFull(exports, name, args) {
     }
   }
   if (isAbsVal(fn)) {
+    if (fn.shape.k === "fn") {
+      try {
+        const r = $call(fn, args);
+        return { result: r, throws: never };
+      } catch (e) {
+        if (isNudoThrow(e)) {
+          return { result: never, throws: e.absValue };
+        }
+        return { result: unknown, throws: never };
+      }
+    }
     return { result: fn, throws: never };
   }
   return { result: unknown, throws: never };
@@ -6805,6 +7162,7 @@ export {
   asAbsVal,
   $fnVal,
   $lit,
+  litTruth,
   isDefinitelyTrue,
   isDefinitelyFalse,
   $fork,
@@ -6820,6 +7178,8 @@ export {
   $concat,
   $elems,
   $forOf,
+  namespaceNameOf,
+  $regex,
   $get,
   $set,
   $while,