@nudojs/cli 0.2.1 → 0.3.1

package/dist/{chunk-3HCPXPEW.js → chunk-YDM4HHQ4.js}

@@ -1,34 +1,5 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+import { createRequire as __nudoCreateRequire } from "module";
+const require = __nudoCreateRequire(import.meta.url);
 
 // src/narrowing.ts
 import {
@@ -38,8 +9,79 @@ import {
   getPrimitiveTypeOf,
   typeValueEquals,
   isSubtypeOf,
-  createRange
+  createRange,
+  v as termVar2
 } from "@nudojs/core";
+
+// src/term-registry.ts
+import { v as termVar, lit } from "@nudojs/core";
+var termByTv = /* @__PURE__ */ new WeakMap();
+var predByTv = /* @__PURE__ */ new WeakMap();
+function attachTerm(tv, term) {
+  if (tv && typeof tv === "object") termByTv.set(tv, term);
+}
+function getTerm(tv) {
+  if (tv && typeof tv === "object") return termByTv.get(tv);
+  return void 0;
+}
+function getPred(tv) {
+  if (tv && typeof tv === "object") return predByTv.get(tv);
+  return void 0;
+}
+function tagParamArg(arg, paramName) {
+  if (!paramName || paramName.startsWith("...")) return arg;
+  if (arg.kind === "function" || arg.kind === "instance") return arg;
+  const cloned = cloneTypeValue(arg);
+  if (cloned.kind === "primitive" && cloned.type === "number") {
+    attachTerm(cloned, termVar(paramName));
+  } else if (cloned.kind === "literal" && typeof cloned.value === "number") {
+    attachTerm(cloned, lit(cloned.value));
+  } else if (cloned.kind === "refined") {
+    attachTerm(cloned, termVar(paramName));
+  }
+  return cloned;
+}
+function cloneTypeValue(tv) {
+  switch (tv.kind) {
+    case "literal":
+      return { kind: "literal", value: tv.value };
+    case "primitive":
+      return { kind: "primitive", type: tv.type };
+    case "refined":
+      return { kind: "refined", base: tv.base, refinement: tv.refinement };
+    case "object":
+      return { kind: "object", properties: tv.properties, id: tv.id };
+    case "array":
+      return { kind: "array", element: tv.element };
+    case "tuple":
+      return { kind: "tuple", elements: tv.elements };
+    case "function":
+      return {
+        kind: "function",
+        params: tv.params,
+        body: tv.body,
+        closure: tv.closure
+      };
+    case "promise":
+      return { kind: "promise", value: tv.value };
+    case "instance":
+      return {
+        kind: "instance",
+        className: tv.className,
+        properties: tv.properties
+      };
+    case "union":
+      return { kind: "union", members: tv.members };
+    case "never":
+      return { kind: "never" };
+    case "unknown":
+      return { kind: "unknown" };
+    default:
+      return tv;
+  }
+}
+
+// src/narrowing.ts
 function narrow(test, env) {
   if (test.type === "LogicalExpression" && (test.operator === "||" || test.operator === "&&")) {
     const [trueOfLeft, falseOfLeft] = narrow(test.left, env);
@@ -271,6 +313,9 @@ function narrowByComparison(varName, op, value, env) {
   const falseEnv = env.extend({});
   const trueRange = op === ">=" ? createRange({ min: value }) : op === ">" ? createRange({ min: value + 1 }) : op === "<=" ? createRange({ max: value }) : createRange({ max: value - 1 });
   const falseRange = op === ">=" ? createRange({ max: value - 1 }) : op === ">" ? createRange({ max: value }) : op === "<=" ? createRange({ min: value + 1 }) : createRange({ min: value });
+  const term = termVar2(varName);
+  attachTerm(trueRange, term);
+  attachTerm(falseRange, term);
   trueEnv.bind(varName, trueRange);
   falseEnv.bind(varName, falseRange);
   return [trueEnv, falseEnv];
@@ -338,121 +383,11 @@ function narrowByTruthy(varName, env) {
   return [trueEnv, falseEnv];
 }
 
-// src/evaluator.ts
-import {
-  T as T12,
-  simplifyUnion as simplifyUnion4,
-  dispatchBinaryOp,
-  dispatchMethod,
-  dispatchProperty,
-  Ops,
-  createEnvironment,
-  typeValueEquals as typeValueEquals4,
-  typeValueToString,
-  isSubtypeOf as isSubtypeOf2,
-  widenLiteral,
-  collapseLiteralUnion,
-  createTemplate,
-  subtractType as subtractType2,
-  getFnSig
-} from "@nudojs/core";
-import { extractInlineDirectives } from "@nudojs/parser";
-
-// src/builtins/builtin-promise.ts
-import { T as T2, simplifyUnion } from "@nudojs/core";
-var PROMISE_STATIC_METHODS = {
-  resolve: T2.unknown,
-  reject: T2.never,
-  all: T2.unknown,
-  race: T2.unknown,
-  allSettled: T2.unknown,
-  any: T2.unknown
-};
-function evaluatePromiseStaticMethod(methodName, args) {
-  if (methodName === "resolve") {
-    if (args.length > 0) return T2.promise(args[0]);
-    return T2.promise(T2.undefined);
-  }
-  if (methodName === "reject") {
-    return T2.promise(T2.never);
-  }
-  if (methodName === "all") {
-    if (args.length > 0 && args[0].kind === "tuple") {
-      const elemTypes = args[0].elements.map((e) => {
-        if (e.kind === "promise") return e.value;
-        return T2.unknown;
-      });
-      return T2.promise(T2.tuple(elemTypes));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      return T2.promise(T2.array(args[0].element));
-    }
-    return T2.promise(T2.array(T2.unknown));
-  }
-  if (methodName === "race") {
-    if (args.length > 0 && args[0].kind === "tuple") {
-      const elemTypes = args[0].elements.map((e) => {
-        if (e.kind === "promise") return e.value;
-        return T2.unknown;
-      });
-      return T2.promise(simplifyUnion(elemTypes));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      const el = args[0].element;
-      return T2.promise(el.kind === "promise" ? el.value : T2.unknown);
-    }
-    return T2.promise(T2.unknown);
-  }
-  if (methodName === "allSettled") {
-    const settledOf = (e) => T2.object({
-      status: T2.union(T2.literal("fulfilled"), T2.literal("rejected")),
-      value: e.kind === "promise" ? e.value : T2.unknown
-    });
-    if (args.length > 0 && args[0].kind === "tuple") {
-      return T2.promise(T2.tuple(args[0].elements.map(settledOf)));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      return T2.promise(T2.array(settledOf(args[0].element)));
-    }
-    return T2.promise(T2.array(T2.unknown));
-  }
-  if (methodName === "any") {
-    if (args.length > 0 && args[0].kind === "tuple") {
-      const elemTypes = args[0].elements.map((e) => {
-        if (e.kind === "promise") return e.value;
-        return T2.unknown;
-      });
-      return T2.promise(simplifyUnion(elemTypes));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      const el = args[0].element;
-      return T2.promise(el.kind === "promise" ? el.value : T2.unknown);
-    }
-    return T2.promise(T2.unknown);
-  }
-  return null;
-}
-function evaluatePromiseInstanceMethod(promiseValue, methodName, args) {
-  if (methodName === "then") {
-    if (promiseValue.kind === "promise") {
-      return T2.promise(T2.unknown);
-    }
-  }
-  if (methodName === "catch") {
-    if (promiseValue.kind === "promise") {
-      return promiseValue;
-    }
-  }
-  if (methodName === "finally") {
-    if (promiseValue.kind === "promise") {
-      return promiseValue;
-    }
-  }
-  return null;
-}
+// src/builtins/builtin-prototype.ts
+import { T as T4, simplifyUnion as simplifyUnion3 } from "@nudojs/core";
 
 // src/builtins/builtin-map.ts
-import { T as T3, simplifyUnion as simplifyUnion2, typeValueEquals as typeValueEquals2 } from "@nudojs/core";
+import { T as T2, simplifyUnion, typeValueEquals as typeValueEquals2 } from "@nudojs/core";
 function entryKeyTrackable(key) {
   return key?.kind === "literal" || key?.kind === "instance";
 }
@@ -460,11 +395,11 @@ function lookupEntries(entries, key) {
   if (key.kind === "union") {
     const results = key.members.map((m) => lookupEntries(entries, m));
     if (results.some((r) => r === null)) return null;
-    return simplifyUnion2(results);
+    return simplifyUnion(results);
   }
   if (!entryKeyTrackable(key)) return null;
   const hit = entries.find((e) => typeValueEquals2(e.key, key));
-  return hit ? hit.value : T3.undefined;
+  return hit ? hit.value : T2.undefined;
 }
 var MAP_INSTANCE_METHODS = {
   get: (key, map) => {
@@ -474,15 +409,15 @@ var MAP_INSTANCE_METHODS = {
       if (looked !== null) return looked;
     }
     const typeArgs = map?._typeArgs;
-    if (typeArgs?.V) return T3.union(typeArgs.V, T3.undefined);
-    return T3.unknown;
+    if (typeArgs?.V) return T2.union(typeArgs.V, T2.undefined);
+    return T2.unknown;
   },
   set: (key, value, map) => {
     if (map) {
-      const typeArgs = map._typeArgs || { K: T3.unknown, V: T3.unknown };
+      const typeArgs = map._typeArgs || { K: T2.unknown, V: T2.unknown };
       map._typeArgs = {
-        K: typeArgs.K.kind === "unknown" ? key : simplifyUnion2([typeArgs.K, key]),
-        V: typeArgs.V.kind === "unknown" ? value : simplifyUnion2([typeArgs.V, value])
+        K: typeArgs.K.kind === "unknown" ? key : simplifyUnion([typeArgs.K, key]),
+        V: typeArgs.V.kind === "unknown" ? value : simplifyUnion([typeArgs.V, value])
       };
       if (entryKeyTrackable(key)) {
         if (map._entries === void 0 && map._entriesExact !== false) {
@@ -499,14 +434,14 @@ var MAP_INSTANCE_METHODS = {
         map._entriesExact = false;
       }
     }
-    return map ?? T3.unknown;
+    return map ?? T2.unknown;
   },
   has: (key, map) => {
     const entries = exactMapEntries(map);
     if (entries && entryKeyTrackable(key)) {
-      return T3.literal(entries.some((e) => typeValueEquals2(e.key, key)));
+      return T2.literal(entries.some((e) => typeValueEquals2(e.key, key)));
     }
-    return T3.boolean;
+    return T2.boolean;
   },
   delete: (key, map) => {
     const entries = exactMapEntries(map);
@@ -514,33 +449,33 @@ var MAP_INSTANCE_METHODS = {
       const idx = entries.findIndex((e) => typeValueEquals2(e.key, key));
       if (idx >= 0) {
         entries.splice(idx, 1);
-        return T3.literal(true);
+        return T2.literal(true);
       }
-      return T3.literal(false);
+      return T2.literal(false);
     }
-    return T3.boolean;
+    return T2.boolean;
   },
   clear: (value, map) => {
     const target = map ?? value;
     if (target && target._entriesExact) {
       target._entries = [];
     }
-    return T3.undefined;
+    return T2.undefined;
   },
-  forEach: () => T3.undefined,
+  forEach: () => T2.undefined,
   keys: (map) => {
     const entries = exactMapEntries(map);
-    if (entries) return T3.tuple(entries.map((e) => e.key));
+    if (entries) return T2.tuple(entries.map((e) => e.key));
     const typeArgs = map?._typeArgs;
-    if (typeArgs?.K) return T3.array(typeArgs.K);
-    return T3.array(T3.unknown);
+    if (typeArgs?.K) return T2.array(typeArgs.K);
+    return T2.array(T2.unknown);
   },
   values: (map) => {
     const entries = exactMapEntries(map);
-    if (entries) return T3.tuple(entries.map((e) => e.value));
+    if (entries) return T2.tuple(entries.map((e) => e.value));
     const typeArgs = map?._typeArgs;
-    if (typeArgs?.V) return T3.array(typeArgs.V);
-    return T3.array(T3.unknown);
+    if (typeArgs?.V) return T2.array(typeArgs.V);
+    return T2.array(T2.unknown);
   },
   entries: (map) => mapEntriesIterable(map)
 };
@@ -550,13 +485,13 @@ function exactMapEntries(map) {
 }
 function mapEntriesIterable(map) {
   const entries = exactMapEntries(map);
-  if (entries) return T3.tuple(entries.map((e) => T3.tuple([e.key, e.value])));
+  if (entries) return T2.tuple(entries.map((e) => T2.tuple([e.key, e.value])));
   const typeArgs = map?._typeArgs;
-  if (typeArgs?.K && typeArgs?.V) return T3.array(T3.tuple([typeArgs.K, typeArgs.V]));
-  return T3.array(T3.tuple([T3.unknown, T3.unknown]));
+  if (typeArgs?.K && typeArgs?.V) return T2.array(T2.tuple([typeArgs.K, typeArgs.V]));
+  return T2.array(T2.tuple([T2.unknown, T2.unknown]));
 }
 function createMapType(args) {
-  const obj = T3.instanceOf("Map", {});
+  const obj = T2.instanceOf("Map", {});
   if (args && args.length > 0) {
     const arg = args[0];
     if (arg.kind === "tuple" || arg.kind === "array") {
@@ -577,7 +512,7 @@ function createMapType(args) {
         }
       }
       if (keys.length > 0) {
-        obj._typeArgs = { K: simplifyUnion2(keys), V: simplifyUnion2(values) };
+        obj._typeArgs = { K: simplifyUnion(keys), V: simplifyUnion(values) };
       }
       if (exact && entries.length > 0) {
         obj._entries = entries;
@@ -588,13 +523,13 @@ function createMapType(args) {
     }
   }
   if (!obj._typeArgs) {
-    obj._typeArgs = { K: T3.unknown, V: T3.unknown };
+    obj._typeArgs = { K: T2.unknown, V: T2.unknown };
   }
   return obj;
 }
 
 // src/builtins/builtin-set.ts
-import { T as T4, simplifyUnion as simplifyUnion3, typeValueEquals as typeValueEquals3 } from "@nudojs/core";
+import { T as T3, simplifyUnion as simplifyUnion2, typeValueEquals as typeValueEquals3 } from "@nudojs/core";
 function valueTrackable(v) {
   return v?.kind === "literal" || v?.kind === "instance";
 }
@@ -610,9 +545,9 @@ function lookupValues(values, value) {
 var SET_INSTANCE_METHODS = {
   add: (value, set) => {
     if (set) {
-      const typeArgs = set._typeArgs || { T: T4.unknown };
+      const typeArgs = set._typeArgs || { T: T3.unknown };
       set._typeArgs = {
-        T: typeArgs.T.kind === "unknown" ? value : simplifyUnion3([typeArgs.T, value])
+        T: typeArgs.T.kind === "unknown" ? value : simplifyUnion2([typeArgs.T, value])
       };
       if (valueTrackable(value)) {
         if (set._values === void 0 && set._valuesExact !== false) {
@@ -627,15 +562,15 @@ var SET_INSTANCE_METHODS = {
         set._valuesExact = false;
       }
     }
-    return set ?? T4.unknown;
+    return set ?? T3.unknown;
   },
   has: (value, set) => {
     const values = exactSetValues(set);
     if (values) {
       const looked = lookupValues(values, value);
-      if (looked !== null) return T4.literal(looked);
+      if (looked !== null) return T3.literal(looked);
     }
-    return T4.boolean;
+    return T3.boolean;
   },
   delete: (value, set) => {
     const values = exactSetValues(set);
@@ -643,29 +578,29 @@ var SET_INSTANCE_METHODS = {
       const idx = values.findIndex((v) => typeValueEquals3(v, value));
       if (idx >= 0) {
         values.splice(idx, 1);
-        return T4.literal(true);
+        return T3.literal(true);
       }
-      return T4.literal(false);
+      return T3.literal(false);
     }
-    return T4.boolean;
+    return T3.boolean;
   },
   clear: (value, set) => {
     const target = set ?? value;
     if (target && target._valuesExact) {
       target._values = [];
     }
-    return T4.undefined;
+    return T3.undefined;
   },
-  forEach: () => T4.undefined,
+  forEach: () => T3.undefined,
   values: (set) => setValuesIterable(set),
   // For Set, keys() is the same as values()
   keys: (set) => setValuesIterable(set),
   entries: (set) => {
     const values = exactSetValues(set);
-    if (values) return T4.tuple(values.map((v) => T4.tuple([v, v])));
+    if (values) return T3.tuple(values.map((v) => T3.tuple([v, v])));
     const typeArgs = set?._typeArgs;
-    if (typeArgs?.T) return T4.array(T4.tuple([typeArgs.T, typeArgs.T]));
-    return T4.array(T4.tuple([T4.unknown, T4.unknown]));
+    if (typeArgs?.T) return T3.array(T3.tuple([typeArgs.T, typeArgs.T]));
+    return T3.array(T3.tuple([T3.unknown, T3.unknown]));
   }
 };
 function exactSetValues(set) {
@@ -674,18 +609,18 @@ function exactSetValues(set) {
 }
 function setValuesIterable(set) {
   const values = exactSetValues(set);
-  if (values) return T4.tuple([...values]);
+  if (values) return T3.tuple([...values]);
   const typeArgs = set?._typeArgs;
-  if (typeArgs?.T) return T4.array(typeArgs.T);
-  return T4.array(T4.unknown);
+  if (typeArgs?.T) return T3.array(typeArgs.T);
+  return T3.array(T3.unknown);
 }
 function createSetType(args) {
-  const obj = T4.instanceOf("Set", {});
+  const obj = T3.instanceOf("Set", {});
   if (args && args.length > 0) {
     const arg = args[0];
     if (arg.kind === "tuple" || arg.kind === "array") {
       const elements = arg.kind === "tuple" ? arg.elements : [arg.element];
-      obj._typeArgs = { T: simplifyUnion3(elements) };
+      obj._typeArgs = { T: simplifyUnion2(elements) };
       const exact = elements.every(valueTrackable);
       if (exact && elements.length > 0) {
         obj._values = elements;
@@ -696,248 +631,918 @@ function createSetType(args) {
     }
   }
   if (!obj._typeArgs) {
-    obj._typeArgs = { T: T4.unknown };
+    obj._typeArgs = { T: T3.unknown };
   }
   return obj;
 }
 
-// src/builtins/builtin-regexp.ts
-import { T as T5 } from "@nudojs/core";
-var REGEXP_INSTANCE_METHODS = {
-  test: () => T5.boolean,
-  exec: () => T5.union(T5.null, T5.object({})),
-  toString: () => T5.string
-};
-var REGEXP_PROPS = {
-  source: T5.string,
-  flags: T5.string,
-  global: T5.boolean,
-  ignoreCase: T5.boolean,
-  multiline: T5.boolean,
-  dotAll: T5.boolean,
-  unicode: T5.boolean,
-  sticky: T5.boolean
-};
-function createRegExpType() {
-  return T5.instanceOf("RegExp", {
-    source: T5.string,
-    flags: T5.string,
-    global: T5.boolean,
-    ignoreCase: T5.boolean,
-    multiline: T5.boolean,
-    dotAll: T5.boolean,
-    unicode: T5.boolean,
-    sticky: T5.boolean,
-    test: T5.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    exec: T5.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    toString: T5.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
-  });
-}
-
-// src/builtins/builtin-url.ts
-import { T as T6 } from "@nudojs/core";
-var URL_PROPS = {
-  href: T6.string,
-  origin: T6.string,
-  protocol: T6.string,
-  host: T6.string,
-  hostname: T6.string,
-  port: T6.string,
-  pathname: T6.string,
-  search: T6.string,
-  hash: T6.string,
-  username: T6.string,
-  password: T6.string
-};
-var URL_INSTANCE_METHODS = {
-  toString: () => T6.string
-};
-var URLSearchParams_INSTANCE_METHODS = {
-  get: () => T6.union(T6.string, T6.null),
-  set: () => T6.undefined,
-  has: () => T6.boolean,
-  delete: () => T6.undefined,
-  append: () => T6.undefined,
-  toString: () => T6.string,
-  getAll: () => T6.array(T6.string)
-};
-function createURLType() {
-  return T6.instanceOf("URL", {
-    href: T6.string,
-    origin: T6.string,
-    protocol: T6.string,
-    host: T6.string,
-    hostname: T6.string,
-    port: T6.string,
-    pathname: T6.string,
-    search: T6.string,
-    hash: T6.string,
-    username: T6.string,
-    password: T6.string,
-    toString: T6.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
-  });
-}
-function createURLSearchParamsType() {
-  return T6.instanceOf("URLSearchParams", {
-    get: T6.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    set: T6.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    has: T6.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    delete: T6.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    append: T6.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    toString: T6.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    getAll: T6.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
-  });
+// src/builtins/builtin-prototype.ts
+function hasOwnProp(props, name) {
+  return Object.prototype.hasOwnProperty.call(props, name);
 }
-
-// src/builtins/builtin-web.ts
-import { T as T7 } from "@nudojs/core";
-var RESPONSE_PROPS = {
-  ok: T7.boolean,
-  status: T7.number,
-  statusText: T7.string,
-  url: T7.string,
-  type: T7.string,
-  redirected: T7.boolean,
-  headers: T7.unknown,
-  // Headers instance
-  body: T7.unknown,
-  bodyUsed: T7.boolean
-};
-var RESPONSE_INSTANCE_METHODS = {
-  json: () => T7.promise(T7.unknown),
-  text: () => T7.promise(T7.string),
-  arrayBuffer: () => T7.promise(T7.unknown),
-  blob: () => T7.promise(T7.unknown),
-  clone: () => T7.unknown,
-  formData: () => T7.promise(T7.unknown)
-};
-var HEADERS_INSTANCE_METHODS = {
-  get: () => T7.union(T7.string, T7.null),
-  set: () => T7.undefined,
-  has: () => T7.boolean,
-  delete: () => T7.undefined,
-  append: () => T7.undefined,
-  entries: () => T7.unknown,
-  keys: () => T7.unknown,
-  values: () => T7.unknown,
-  forEach: () => T7.undefined
-};
-var FORMDATA_INSTANCE_METHODS = {
-  get: () => T7.union(T7.string, T7.null),
-  set: () => T7.undefined,
-  has: () => T7.boolean,
-  delete: () => T7.undefined,
-  append: () => T7.undefined,
-  getAll: () => T7.array(T7.unknown),
-  entries: () => T7.unknown,
-  keys: () => T7.unknown,
-  values: () => T7.unknown,
-  forEach: () => T7.undefined
-};
-var ABORTCONTROLLER_PROPS = {
-  signal: T7.unknown
+var BUILTIN_ERROR_CLASSES = /* @__PURE__ */ new Set([
+  "Error",
+  "TypeError",
+  "SyntaxError",
+  "RangeError",
+  "ReferenceError",
+  "URIError",
+  "EvalError"
+]);
+var BUILTIN_PROTOTYPE_CLASSES = /* @__PURE__ */ new Set([
+  ...BUILTIN_ERROR_CLASSES,
+  "Date",
+  "Object",
+  "Map",
+  "Set",
+  "Promise",
+  "RegExp",
+  "Array",
+  "Function",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "WeakMap",
+  "WeakSet",
+  "Buffer"
+]);
+var OBJECT_PROTOTYPE_METHODS = {
+  hasOwnProperty: T4.fnSig([T4.unknown], T4.boolean),
+  isPrototypeOf: T4.fnSig([T4.unknown], T4.boolean),
+  propertyIsEnumerable: T4.fnSig([T4.unknown], T4.boolean),
+  toString: T4.fnSig([], T4.string, T4.never, (_args, thisVal) => objectToStringBrand(thisVal)),
+  toLocaleString: T4.fnSig([], T4.string),
+  valueOf: T4.fnSig([], T4.unknown, T4.never, (_args, thisVal) => thisVal)
 };
-var ABORTCONTROLLER_INSTANCE_METHODS = {
-  abort: () => T7.undefined
+var BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS = {
+  Object: { ...OBJECT_PROTOTYPE_METHODS },
+  Array: {
+    push: T4.fnSig([T4.unknown], T4.number),
+    pop: T4.fnSig([], T4.unknown),
+    shift: T4.fnSig([], T4.unknown),
+    unshift: T4.fnSig([T4.unknown], T4.number),
+    slice: T4.fnSig([T4.number, T4.number], T4.array(T4.unknown)),
+    splice: T4.fnSig([T4.number, T4.number], T4.array(T4.unknown)),
+    concat: T4.fnSig([T4.unknown], T4.array(T4.unknown)),
+    join: T4.fnSig([T4.string], T4.string),
+    indexOf: T4.fnSig([T4.unknown], T4.number),
+    lastIndexOf: T4.fnSig([T4.unknown], T4.number),
+    includes: T4.fnSig([T4.unknown], T4.boolean),
+    map: T4.fnSig([T4.unknown], T4.array(T4.unknown)),
+    flatMap: T4.fnSig([T4.unknown], T4.array(T4.unknown)),
+    filter: T4.fnSig([T4.unknown], T4.array(T4.unknown)),
+    forEach: T4.fnSig([T4.unknown], T4.undefined),
+    find: T4.fnSig([T4.unknown], T4.unknown),
+    findIndex: T4.fnSig([T4.unknown], T4.number),
+    some: T4.fnSig([T4.unknown], T4.boolean),
+    every: T4.fnSig([T4.unknown], T4.boolean),
+    reduce: T4.fnSig([T4.unknown, T4.unknown], T4.unknown),
+    sort: T4.fnSig([T4.unknown], T4.array(T4.unknown)),
+    reverse: T4.fnSig([], T4.array(T4.unknown)),
+    toString: T4.fnSig([], T4.string)
+  },
+  Function: {
+    call: T4.fnSig([T4.unknown], T4.unknown),
+    apply: T4.fnSig([T4.unknown, T4.unknown], T4.unknown),
+    bind: T4.fnSig([T4.unknown], T4.unknown),
+    toString: T4.fnSig([], T4.string)
+  },
+  Map: {
+    // Impl-routed: `Map.prototype.m.call(instance)` (and direct prototype
+    // calls) consult the receiver's exact entry side table, making the
+    // hoek deepEqual reflection idioms decide literally.
+    get: T4.fnSig([T4.unknown], T4.unknown, T4.never, (args, thisVal) => MAP_INSTANCE_METHODS.get(args[0] ?? T4.unknown, thisVal ?? T4.unknown)),
+    set: T4.fnSig([T4.unknown, T4.unknown], T4.unknown, T4.never, (args, thisVal) => MAP_INSTANCE_METHODS.set(args[0] ?? T4.unknown, args[1] ?? T4.unknown, thisVal ?? T4.unknown)),
+    has: T4.fnSig([T4.unknown], T4.boolean, T4.never, (args, thisVal) => MAP_INSTANCE_METHODS.has(args[0] ?? T4.unknown, thisVal ?? T4.unknown)),
+    delete: T4.fnSig([T4.unknown], T4.boolean, T4.never, (args, thisVal) => MAP_INSTANCE_METHODS.delete(args[0] ?? T4.unknown, thisVal ?? T4.unknown)),
+    clear: T4.fnSig([], T4.undefined, T4.never, (args, thisVal) => MAP_INSTANCE_METHODS.clear(args[0] ?? T4.unknown, thisVal ?? T4.unknown)),
+    forEach: T4.fnSig([T4.unknown], T4.undefined),
+    keys: T4.fnSig([], T4.array(T4.unknown), T4.never, (_args, thisVal) => MAP_INSTANCE_METHODS.keys(thisVal ?? T4.unknown)),
+    values: T4.fnSig([], T4.array(T4.unknown), T4.never, (_args, thisVal) => MAP_INSTANCE_METHODS.values(thisVal ?? T4.unknown)),
+    entries: T4.fnSig([], T4.array(T4.tuple([T4.unknown, T4.unknown])), T4.never, (_args, thisVal) => mapEntriesIterable(thisVal ?? T4.unknown)),
+    toString: T4.fnSig([], T4.string)
+  },
+  Set: {
+    // Impl-routed like Map above (Set.prototype.values.call(s) ≡ s.values()).
+    add: T4.fnSig([T4.unknown], T4.unknown, T4.never, (args, thisVal) => SET_INSTANCE_METHODS.add(args[0] ?? T4.unknown, thisVal ?? T4.unknown)),
+    has: T4.fnSig([T4.unknown], T4.boolean, T4.never, (args, thisVal) => SET_INSTANCE_METHODS.has(args[0] ?? T4.unknown, thisVal ?? T4.unknown)),
+    delete: T4.fnSig([T4.unknown], T4.boolean, T4.never, (args, thisVal) => SET_INSTANCE_METHODS.delete(args[0] ?? T4.unknown, thisVal ?? T4.unknown)),
+    clear: T4.fnSig([], T4.undefined, T4.never, (args, thisVal) => SET_INSTANCE_METHODS.clear(args[0] ?? T4.unknown, thisVal ?? T4.unknown)),
+    forEach: T4.fnSig([T4.unknown], T4.undefined),
+    keys: T4.fnSig([], T4.array(T4.unknown), T4.never, (_args, thisVal) => SET_INSTANCE_METHODS.keys(thisVal ?? T4.unknown)),
+    values: T4.fnSig([], T4.array(T4.unknown), T4.never, (_args, thisVal) => SET_INSTANCE_METHODS.values(thisVal ?? T4.unknown)),
+    entries: T4.fnSig([], T4.array(T4.tuple([T4.unknown, T4.unknown])), T4.never, (_args, thisVal) => SET_INSTANCE_METHODS.entries(thisVal ?? T4.unknown)),
+    toString: T4.fnSig([], T4.string)
+  },
+  WeakMap: {
+    get: T4.fnSig([T4.unknown], T4.unknown),
+    set: T4.fnSig([T4.unknown, T4.unknown], T4.unknown),
+    has: T4.fnSig([T4.unknown], T4.boolean),
+    delete: T4.fnSig([T4.unknown], T4.boolean),
+    toString: T4.fnSig([], T4.string)
+  },
+  WeakSet: {
+    add: T4.fnSig([T4.unknown], T4.unknown),
+    has: T4.fnSig([T4.unknown], T4.boolean),
+    delete: T4.fnSig([T4.unknown], T4.boolean),
+    toString: T4.fnSig([], T4.string)
+  },
+  Promise: {
+    then: T4.fnSig([T4.unknown], T4.promise(T4.unknown)),
+    catch: T4.fnSig([T4.unknown], T4.promise(T4.unknown)),
+    finally: T4.fnSig([T4.unknown], T4.promise(T4.unknown)),
+    toString: T4.fnSig([], T4.string)
+  },
+  Date: {
+    getTime: T4.fnSig([], T4.number),
+    valueOf: T4.fnSig([], T4.number),
+    toISOString: T4.fnSig([], T4.string),
+    toJSON: T4.fnSig([], T4.string),
+    toLocaleString: T4.fnSig([], T4.string),
+    toString: T4.fnSig([], T4.string)
+  },
+  RegExp: {
+    test: T4.fnSig([T4.string], T4.boolean),
+    exec: T4.fnSig([T4.string], T4.union(T4.object({}), T4.null)),
+    toString: T4.fnSig([], T4.string)
+  },
+  String: {
+    charAt: T4.fnSig([T4.number], T4.string),
+    charCodeAt: T4.fnSig([T4.number], T4.number),
+    indexOf: T4.fnSig([T4.string], T4.number),
+    lastIndexOf: T4.fnSig([T4.string], T4.number),
+    includes: T4.fnSig([T4.string], T4.boolean),
+    startsWith: T4.fnSig([T4.string], T4.boolean),
+    endsWith: T4.fnSig([T4.string], T4.boolean),
+    slice: T4.fnSig([T4.number, T4.number], T4.string),
+    substring: T4.fnSig([T4.number, T4.number], T4.string),
+    toUpperCase: T4.fnSig([], T4.string),
+    toLowerCase: T4.fnSig([], T4.string),
+    trim: T4.fnSig([], T4.string),
+    replace: T4.fnSig([T4.unknown, T4.string], T4.string),
+    split: T4.fnSig([T4.string], T4.array(T4.string)),
+    toString: T4.fnSig([], T4.string),
+    valueOf: T4.fnSig([], T4.string)
+  },
+  Number: {
+    toFixed: T4.fnSig([T4.number], T4.string),
+    toPrecision: T4.fnSig([T4.number], T4.string),
+    valueOf: T4.fnSig([], T4.number),
+    toString: T4.fnSig([T4.number], T4.string)
+  },
+  Boolean: {
+    valueOf: T4.fnSig([], T4.boolean),
+    toString: T4.fnSig([], T4.string)
+  },
+  Symbol: {
+    toString: T4.fnSig([], T4.string),
+    valueOf: T4.fnSig([], T4.symbol)
+  },
+  Buffer: {
+    equals: T4.fnSig([T4.unknown], T4.boolean),
+    compare: T4.fnSig([T4.unknown], T4.number),
+    toString: T4.fnSig([T4.unknown], T4.string),
+    toJSON: T4.fnSig([], T4.unknown)
+  },
+  Error: {
+    toString: T4.fnSig([], T4.string)
+  }
 };
-function createResponseType() {
-  return T7.instanceOf("Response", {
-    ok: T7.boolean,
-    status: T7.number,
-    statusText: T7.string,
-    url: T7.string,
-    type: T7.string,
-    redirected: T7.boolean,
-    headers: T7.unknown,
-    body: T7.unknown,
-    bodyUsed: T7.boolean,
-    json: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    text: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    arrayBuffer: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    blob: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    clone: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    formData: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
-  });
-}
-function createHeadersType() {
-  return T7.instanceOf("Headers", {
-    get: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    set: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    has: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    delete: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    append: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    entries: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    keys: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    values: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    forEach: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
-  });
-}
-function createFormDataType() {
-  return T7.instanceOf("FormData", {
-    get: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    set: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    has: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    delete: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    append: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    getAll: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    entries: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    keys: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    values: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    forEach: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
-  });
+var _builtinClassValues = /* @__PURE__ */ new Map();
+function builtinClassValue(name) {
+  let v = _builtinClassValues.get(name);
+  if (v === void 0) {
+    v = T4.object({});
+    v._builtinName = name;
+    _builtinClassValues.set(name, v);
+  }
+  return v;
 }
-function createAbortControllerType() {
-  return T7.instanceOf("AbortController", {
-    signal: T7.unknown,
-    abort: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
-  });
+var BUILTIN_PROTOTYPE_SINGLETONS = /* @__PURE__ */ new Map();
+function builtinPrototype(className) {
+  let proto = BUILTIN_PROTOTYPE_SINGLETONS.get(className);
+  if (!proto) {
+    const methods = hasOwnProp(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className] : BUILTIN_ERROR_CLASSES.has(className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Error : {};
+    proto = T4.instanceOf(className, { ...methods });
+    proto._builtinProto = className;
+    BUILTIN_PROTOTYPE_SINGLETONS.set(className, proto);
+  }
+  return proto;
 }
-
-// src/builtins/builtin-weak.ts
-import { T as T8 } from "@nudojs/core";
-var WEAKMAP_INSTANCE_METHODS = {
-  get: (_key) => T8.union(T8.unknown, T8.undefined),
-  set: (_key, _value, map) => map ?? T8.unknown,
-  has: () => T8.boolean,
-  delete: () => T8.boolean
-};
-var WEAKSET_INSTANCE_METHODS = {
-  add: (_value, set) => set ?? T8.unknown,
+function objectToStringBrand(v) {
+  if (!v) return void 0;
+  if (v.kind === "union") {
+    const parts = v.members.map((m) => objectToStringBrand(m));
+    if (parts.some((p) => p === void 0)) return void 0;
+    return simplifyUnion3(parts);
+  }
+  let base = v;
+  while (base.kind === "refined") base = base.base;
+  switch (base.kind) {
+    case "object":
+      return T4.literal("[object Object]");
+    case "array":
+    case "tuple":
+      return T4.literal("[object Array]");
+    case "function":
+      return T4.literal("[object Function]");
+    case "promise":
+      return T4.literal("[object Promise]");
+    case "instance":
+      return T4.literal(`[object ${base.className}]`);
+    case "literal": {
+      if (base.value === null) return T4.literal("[object Null]");
+      if (base.value === void 0) return T4.literal("[object Undefined]");
+      const t = typeof base.value;
+      return T4.literal(`[object ${t === "number" ? "Number" : t === "string" ? "String" : "Boolean"}]`);
+    }
+    case "primitive": {
+      const brands = {
+        number: "Number",
+        string: "String",
+        boolean: "Boolean",
+        bigint: "BigInt",
+        symbol: "Symbol"
+      };
+      return T4.literal(`[object ${brands[base.type] ?? "Object"}]`);
+    }
+    default:
+      return void 0;
+  }
+}
+function protoOfValue(v) {
+  if (!v) return T4.unknown;
+  if (v.kind === "union") return simplifyUnion3(v.members.map((m) => protoOfValue(m)));
+  let base = v;
+  while (base.kind === "refined") base = base.base;
+  switch (base.kind) {
+    case "object":
+      return builtinPrototype("Object");
+    case "array":
+    case "tuple":
+      return builtinPrototype("Array");
+    case "function":
+      return builtinPrototype("Function");
+    case "promise":
+      return builtinPrototype("Promise");
+    case "instance":
+      return builtinPrototype(base.className);
+    default:
+      return T4.unknown;
+  }
+}
+
+// src/evaluator.ts
+import {
+  T as T15,
+  simplifyUnion as simplifyUnion8,
+  dispatchMethod,
+  dispatchProperty,
+  Ops,
+  createEnvironment,
+  typeValueEquals as typeValueEquals4,
+  typeValueToString,
+  isSubtypeOf as isSubtypeOf2,
+  widenLiteral,
+  collapseLiteralUnion,
+  createTemplate,
+  subtractType as subtractType2,
+  getFnSig
+} from "@nudojs/core";
+import { extractInlineDirectives } from "@nudojs/parser";
+
+// src/abs-route.ts
+import {
+  typeValueToAbs,
+  absToTypeValue,
+  simplifyUnion as simplifyUnion4,
+  add as kAdd,
+  sub as kSub,
+  mul as kMul,
+  div as kDiv,
+  mod as kMod,
+  cmp as kCmp,
+  typeofAbs as kTypeof,
+  negAbs as kNeg,
+  notAbs as kNot,
+  strictEqAbs as kStrictEq,
+  and as predAnd,
+  ge as predGe,
+  le as predLe,
+  lit as termLit,
+  getRangeMeta,
+  spread as kSpread,
+  joinAbs as kJoinAbs,
+  abs as makeAbs,
+  boolLit,
+  currentPhi,
+  pushPhi,
+  popPhi,
+  resetPhi,
+  withPhiConstraint,
+  describePhi
+} from "@nudojs/core";
+var ARITH_OPS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%"]);
+var CMP_OPS = /* @__PURE__ */ new Set(["<", "<=", ">", ">="]);
+var EQ_OPS = /* @__PURE__ */ new Set(["===", "!=="]);
+var UNARY_OPS = /* @__PURE__ */ new Set(["typeof", "!", "-"]);
+function isNumericOperand(tv) {
+  if (!tv) return false;
+  if (tv.kind === "literal") return typeof tv.value === "number";
+  if (tv.kind === "primitive") return tv.type === "number";
+  if (tv.kind === "refined") return isNumericOperand(tv.base);
+  return false;
+}
+function isStringOperand(tv) {
+  if (!tv) return false;
+  if (tv.kind === "literal") return typeof tv.value === "string";
+  if (tv.kind === "primitive") return tv.type === "string";
+  if (tv.kind === "refined") return isStringOperand(tv.base);
+  return false;
+}
+function isComparableOperand(tv) {
+  if (tv.kind === "literal") {
+    return typeof tv.value === "number" || typeof tv.value === "string";
+  }
+  if (tv.kind === "primitive") return tv.type === "number" || tv.type === "string";
+  if (tv.kind === "refined") return isComparableOperand(tv.base);
+  return false;
+}
+function hasCustomRefinementOp(tv, op) {
+  if (op !== "/" && op !== "%") return false;
+  let cur = tv;
+  while (cur && cur.kind === "refined") {
+    if (cur.refinement.ops?.[op]) return true;
+    cur = cur.base;
+  }
+  return false;
+}
+function canAdd(left, right) {
+  if (isNumericOperand(left) && isNumericOperand(right)) return true;
+  if (isStringOperand(left) || isStringOperand(right)) return true;
+  if (left.kind === "refined" && isStringOperand(left.base)) return true;
+  if (right.kind === "refined" && isStringOperand(right.base)) return true;
+  return false;
+}
+function toAbsWithTerms(tv) {
+  const base = typeValueToAbs(tv);
+  const term = getTerm(tv);
+  const pred = getPred(tv);
+  let abs = !term && !pred && !getRangeMeta(tv) ? base : makeAbs(base.shape, term ?? base.term, pred ?? base.pred, base.conf);
+  const range = getRangeMeta(tv);
+  if (range && abs.term) {
+    const facts = [];
+    if (range.min != null) facts.push(predGe(abs.term, termLit(range.min)));
+    if (range.max != null) facts.push(predLe(abs.term, termLit(range.max)));
+    if (facts.length > 0) {
+      const existing = abs.pred && abs.pred.op !== "true" ? abs.pred : void 0;
+      abs = makeAbs(
+        abs.shape,
+        abs.term,
+        existing ? predAnd(existing, ...facts) : predAnd(...facts),
+        abs.conf
+      );
+    }
+  }
+  return abs;
+}
+function tryAbsBinary(op, left, right) {
+  if (!ARITH_OPS.has(op) && !CMP_OPS.has(op) && !EQ_OPS.has(op)) return void 0;
+  if (left.kind === "union" || right.kind === "union") {
+    const ls = left.kind === "union" ? left.members : [left];
+    const rs = right.kind === "union" ? right.members : [right];
+    const results = [];
+    for (const l of ls) {
+      for (const r of rs) {
+        const one = tryAbsBinary(op, l, r);
+        if (one === void 0) return void 0;
+        results.push(one);
+      }
+    }
+    return simplifyUnion4(results);
+  }
+  if (hasCustomRefinementOp(left, op) || hasCustomRefinementOp(right, op)) {
+    return void 0;
+  }
+  if (op === "+") {
+    if (!canAdd(left, right)) return void 0;
+  } else if (op === "-" || op === "*" || op === "/" || op === "%") {
+    if (!isNumericOperand(left) || !isNumericOperand(right)) return void 0;
+  } else if (op === "===" || op === "!==") {
+  } else {
+    if (!isComparableOperand(left) || !isComparableOperand(right)) return void 0;
+  }
+  try {
+    const la = toAbsWithTerms(left);
+    const ra = toAbsWithTerms(right);
+    const phi = currentPhi();
+    if (op === "===" || op === "!==") {
+      const eq = kStrictEq(la, ra);
+      if (eq !== void 0) {
+        return absToTypeValue(op === "===" ? boolLit(eq) : boolLit(!eq));
+      }
+      if (isNumericOperand(left) && isNumericOperand(right)) {
+        return absToTypeValue(kCmp(op === "===" ? "eq" : "ne", la, ra, phi));
+      }
+      return void 0;
+    }
+    let result;
+    if (op === "+") result = kAdd(la, ra, phi);
+    else if (op === "-") result = kSub(la, ra, phi);
+    else if (op === "*") result = kMul(la, ra, phi);
+    else if (op === "/") result = kDiv(la, ra, phi);
+    else if (op === "%") result = kMod(la, ra, phi);
+    else if (op === "<") result = kCmp("lt", la, ra, phi);
+    else if (op === "<=") result = kCmp("le", la, ra, phi);
+    else if (op === ">") result = kCmp("gt", la, ra, phi);
+    else if (op === ">=") result = kCmp("ge", la, ra, phi);
+    else return void 0;
+    return absToTypeValue(result);
+  } catch {
+    return void 0;
+  }
+}
+function tryAbsUnary(op, operand) {
+  if (!UNARY_OPS.has(op)) return void 0;
+  if (operand.kind === "union") {
+    const outs = [];
+    for (const m of operand.members) {
+      const one = tryAbsUnary(op, m);
+      if (one === void 0) return void 0;
+      outs.push(one);
+    }
+    return simplifyUnion4(outs);
+  }
+  try {
+    const a = toAbsWithTerms(operand);
+    if (op === "typeof") return absToTypeValue(kTypeof(a));
+    if (op === "!") return absToTypeValue(kNot(a));
+    if (op === "-") {
+      if (!isNumericOperand(operand) && operand.kind !== "unknown") return void 0;
+      return absToTypeValue(kNeg(a, currentPhi()));
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function tryAbsObjectSpread(base, over) {
+  if (base.kind !== "object" && base.kind !== "union") return void 0;
+  if (over.kind !== "object" && over.kind !== "union") return void 0;
+  try {
+    const ba = toAbsWithTerms(base);
+    const oa = toAbsWithTerms(over);
+    const r = kSpread(ba, oa);
+    return absToTypeValue(r);
+  } catch {
+    return void 0;
+  }
+}
+function tryAbsJoinObjects(a, b) {
+  if (a.kind !== "object" || b.kind !== "object") return void 0;
+  try {
+    const r = kJoinAbs(toAbsWithTerms(a), toAbsWithTerms(b));
+    return absToTypeValue(r);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/eval-binary.ts
+import {
+  T as T5,
+  simplifyUnion as simplifyUnion5,
+  dispatchBinaryOp
+} from "@nudojs/core";
+var MAX_UNION_PRODUCT = 64;
+function looseLiteralValue(tv) {
+  if (tv.kind === "literal") {
+    const v = tv.value;
+    if (typeof v === "number" || typeof v === "string" || typeof v === "boolean" || v === null || v === void 0) {
+      return { hit: true, v };
+    }
+  }
+  return { hit: false, v: void 0 };
+}
+function distributeBinaryOverUnion(left, right, fn) {
+  if (left.kind === "union" && right.kind === "union") {
+    if (left.members.length * right.members.length > MAX_UNION_PRODUCT) {
+      return T5.unknown;
+    }
+    return simplifyUnion5(
+      left.members.flatMap((l) => right.members.map((r) => fn(l, r)))
+    );
+  }
+  if (left.kind === "union") {
+    return simplifyUnion5(left.members.map((l) => fn(l, right)));
+  }
+  if (right.kind === "union") {
+    return simplifyUnion5(right.members.map((r) => fn(left, r)));
+  }
+  return fn(left, right);
+}
+var ALGEBRA_OPS = /* @__PURE__ */ new Set([
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "===",
+  "!=="
+]);
+function numberish(tv) {
+  if (!tv) return false;
+  if (tv.kind === "unknown") return true;
+  if (tv.kind === "literal") return typeof tv.value === "number";
+  if (tv.kind === "primitive") return tv.type === "number";
+  if (tv.kind === "refined") return numberish(tv.base);
+  return false;
+}
+function evalBinaryValue(operator, left, right) {
+  if (operator === "instanceof" || operator === "in") return void 0;
+  if (ALGEBRA_OPS.has(operator)) {
+    const absResult = tryAbsBinary(operator, left, right);
+    if (absResult !== void 0) return absResult;
+  }
+  if (operator === "==" || operator === "!=") {
+    const eq = operator === "==";
+    return distributeBinaryOverUnion(left, right, (l, r) => {
+      const lv = looseLiteralValue(l);
+      const rv = looseLiteralValue(r);
+      if (lv.hit && rv.hit) return T5.literal(eq ? lv.v == rv.v : lv.v != rv.v);
+      return T5.boolean;
+    });
+  }
+  const viaDispatch = distributeBinaryOverUnion(
+    left,
+    right,
+    (l, r) => dispatchBinaryOp(operator, l, r)
+  );
+  if (viaDispatch.kind === "unknown" && (operator === "-" || operator === "*" || operator === "/" || operator === "%") && (numberish(left) || numberish(right))) {
+    return T5.number;
+  }
+  return viaDispatch;
+}
+
+// src/phi-from-test.ts
+import { pTrue as pTrue2, and as phiAnd, gt, ge, lt, le, v as termVar3, lit as lit2 } from "@nudojs/core";
+function phiFromTest(test) {
+  if (test.type !== "BinaryExpression") {
+    return { whenTrue: pTrue2, whenFalse: pTrue2 };
+  }
+  const op = test.operator;
+  const left = test.left;
+  const right = test.right;
+  if (left.type === "Identifier" && right.type === "NumericLiteral" && (op === ">" || op === ">=" || op === "<" || op === "<=")) {
+    const t = termVar3(left.name);
+    const n = lit2(right.value);
+    const pred = op === ">" ? gt(t, n) : op === ">=" ? ge(t, n) : op === "<" ? lt(t, n) : le(t, n);
+    const dual = op === ">" ? le(t, n) : op === ">=" ? lt(t, n) : op === "<" ? ge(t, n) : gt(t, n);
+    return { whenTrue: pred, whenFalse: dual };
+  }
+  return { whenTrue: pTrue2, whenFalse: pTrue2 };
+}
+function combinePhi(base, extra) {
+  if (extra.op === "true") return base;
+  if (base.op === "true") return extra;
+  return phiAnd(base, extra);
+}
+
+// src/builtins/builtin-promise.ts
+import { T as T6, simplifyUnion as simplifyUnion6 } from "@nudojs/core";
+var PROMISE_STATIC_METHODS = {
+  resolve: T6.unknown,
+  reject: T6.never,
+  all: T6.unknown,
+  race: T6.unknown,
+  allSettled: T6.unknown,
+  any: T6.unknown
+};
+function evaluatePromiseStaticMethod(methodName, args) {
+  if (methodName === "resolve") {
+    if (args.length > 0) return T6.promise(args[0]);
+    return T6.promise(T6.undefined);
+  }
+  if (methodName === "reject") {
+    return T6.promise(T6.never);
+  }
+  if (methodName === "all") {
+    if (args.length > 0 && args[0].kind === "tuple") {
+      const elemTypes = args[0].elements.map((e) => {
+        if (e.kind === "promise") return e.value;
+        return T6.unknown;
+      });
+      return T6.promise(T6.tuple(elemTypes));
+    }
+    if (args.length > 0 && args[0].kind === "array") {
+      return T6.promise(T6.array(args[0].element));
+    }
+    return T6.promise(T6.array(T6.unknown));
+  }
+  if (methodName === "race") {
+    if (args.length > 0 && args[0].kind === "tuple") {
+      const elemTypes = args[0].elements.map((e) => {
+        if (e.kind === "promise") return e.value;
+        return T6.unknown;
+      });
+      return T6.promise(simplifyUnion6(elemTypes));
+    }
+    if (args.length > 0 && args[0].kind === "array") {
+      const el = args[0].element;
+      return T6.promise(el.kind === "promise" ? el.value : T6.unknown);
+    }
+    return T6.promise(T6.unknown);
+  }
+  if (methodName === "allSettled") {
+    const settledOf = (e) => T6.object({
+      status: T6.union(T6.literal("fulfilled"), T6.literal("rejected")),
+      value: e.kind === "promise" ? e.value : T6.unknown
+    });
+    if (args.length > 0 && args[0].kind === "tuple") {
+      return T6.promise(T6.tuple(args[0].elements.map(settledOf)));
+    }
+    if (args.length > 0 && args[0].kind === "array") {
+      return T6.promise(T6.array(settledOf(args[0].element)));
+    }
+    return T6.promise(T6.array(T6.unknown));
+  }
+  if (methodName === "any") {
+    if (args.length > 0 && args[0].kind === "tuple") {
+      const elemTypes = args[0].elements.map((e) => {
+        if (e.kind === "promise") return e.value;
+        return T6.unknown;
+      });
+      return T6.promise(simplifyUnion6(elemTypes));
+    }
+    if (args.length > 0 && args[0].kind === "array") {
+      const el = args[0].element;
+      return T6.promise(el.kind === "promise" ? el.value : T6.unknown);
+    }
+    return T6.promise(T6.unknown);
+  }
+  return null;
+}
+function evaluatePromiseInstanceMethod(promiseValue, methodName, args) {
+  if (methodName === "then") {
+    if (promiseValue.kind === "promise") {
+      return T6.promise(T6.unknown);
+    }
+  }
+  if (methodName === "catch") {
+    if (promiseValue.kind === "promise") {
+      return promiseValue;
+    }
+  }
+  if (methodName === "finally") {
+    if (promiseValue.kind === "promise") {
+      return promiseValue;
+    }
+  }
+  return null;
+}
+
+// src/builtins/builtin-regexp.ts
+import { T as T7 } from "@nudojs/core";
+var REGEXP_INSTANCE_METHODS = {
+  test: () => T7.boolean,
+  exec: () => T7.union(T7.null, T7.object({})),
+  toString: () => T7.string
+};
+var REGEXP_PROPS = {
+  source: T7.string,
+  flags: T7.string,
+  global: T7.boolean,
+  ignoreCase: T7.boolean,
+  multiline: T7.boolean,
+  dotAll: T7.boolean,
+  unicode: T7.boolean,
+  sticky: T7.boolean
+};
+function createRegExpType() {
+  return T7.instanceOf("RegExp", {
+    source: T7.string,
+    flags: T7.string,
+    global: T7.boolean,
+    ignoreCase: T7.boolean,
+    multiline: T7.boolean,
+    dotAll: T7.boolean,
+    unicode: T7.boolean,
+    sticky: T7.boolean,
+    test: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    exec: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    toString: T7.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
+  });
+}
+
+// src/builtins/builtin-url.ts
+import { T as T8 } from "@nudojs/core";
+var URL_PROPS = {
+  href: T8.string,
+  origin: T8.string,
+  protocol: T8.string,
+  host: T8.string,
+  hostname: T8.string,
+  port: T8.string,
+  pathname: T8.string,
+  search: T8.string,
+  hash: T8.string,
+  username: T8.string,
+  password: T8.string
+};
+var URL_INSTANCE_METHODS = {
+  toString: () => T8.string
+};
+var URLSearchParams_INSTANCE_METHODS = {
+  get: () => T8.union(T8.string, T8.null),
+  set: () => T8.undefined,
   has: () => T8.boolean,
-  delete: () => T8.boolean
+  delete: () => T8.undefined,
+  append: () => T8.undefined,
+  toString: () => T8.string,
+  getAll: () => T8.array(T8.string)
+};
+function createURLType() {
+  return T8.instanceOf("URL", {
+    href: T8.string,
+    origin: T8.string,
+    protocol: T8.string,
+    host: T8.string,
+    hostname: T8.string,
+    port: T8.string,
+    pathname: T8.string,
+    search: T8.string,
+    hash: T8.string,
+    username: T8.string,
+    password: T8.string,
+    toString: T8.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
+  });
+}
+function createURLSearchParamsType() {
+  return T8.instanceOf("URLSearchParams", {
+    get: T8.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    set: T8.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    has: T8.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    delete: T8.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    append: T8.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    toString: T8.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    getAll: T8.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
+  });
+}
+
+// src/builtins/builtin-web.ts
+import { T as T9 } from "@nudojs/core";
+var RESPONSE_PROPS = {
+  ok: T9.boolean,
+  status: T9.number,
+  statusText: T9.string,
+  url: T9.string,
+  type: T9.string,
+  redirected: T9.boolean,
+  headers: T9.unknown,
+  // Headers instance
+  body: T9.unknown,
+  bodyUsed: T9.boolean
+};
+var RESPONSE_INSTANCE_METHODS = {
+  json: () => T9.promise(T9.unknown),
+  text: () => T9.promise(T9.string),
+  arrayBuffer: () => T9.promise(T9.unknown),
+  blob: () => T9.promise(T9.unknown),
+  clone: () => T9.unknown,
+  formData: () => T9.promise(T9.unknown)
+};
+var HEADERS_INSTANCE_METHODS = {
+  get: () => T9.union(T9.string, T9.null),
+  set: () => T9.undefined,
+  has: () => T9.boolean,
+  delete: () => T9.undefined,
+  append: () => T9.undefined,
+  entries: () => T9.unknown,
+  keys: () => T9.unknown,
+  values: () => T9.unknown,
+  forEach: () => T9.undefined
+};
+var FORMDATA_INSTANCE_METHODS = {
+  get: () => T9.union(T9.string, T9.null),
+  set: () => T9.undefined,
+  has: () => T9.boolean,
+  delete: () => T9.undefined,
+  append: () => T9.undefined,
+  getAll: () => T9.array(T9.unknown),
+  entries: () => T9.unknown,
+  keys: () => T9.unknown,
+  values: () => T9.unknown,
+  forEach: () => T9.undefined
+};
+var ABORTCONTROLLER_PROPS = {
+  signal: T9.unknown
+};
+var ABORTCONTROLLER_INSTANCE_METHODS = {
+  abort: () => T9.undefined
+};
+function createResponseType() {
+  return T9.instanceOf("Response", {
+    ok: T9.boolean,
+    status: T9.number,
+    statusText: T9.string,
+    url: T9.string,
+    type: T9.string,
+    redirected: T9.boolean,
+    headers: T9.unknown,
+    body: T9.unknown,
+    bodyUsed: T9.boolean,
+    json: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    text: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    arrayBuffer: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    blob: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    clone: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    formData: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
+  });
+}
+function createHeadersType() {
+  return T9.instanceOf("Headers", {
+    get: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    set: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    has: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    delete: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    append: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    entries: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    keys: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    values: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    forEach: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
+  });
+}
+function createFormDataType() {
+  return T9.instanceOf("FormData", {
+    get: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    set: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    has: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    delete: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    append: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    getAll: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    entries: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    keys: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    values: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    forEach: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
+  });
+}
+function createAbortControllerType() {
+  return T9.instanceOf("AbortController", {
+    signal: T9.unknown,
+    abort: T9.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
+  });
+}
+
+// src/builtins/builtin-weak.ts
+import { T as T10 } from "@nudojs/core";
+var WEAKMAP_INSTANCE_METHODS = {
+  get: (_key) => T10.union(T10.unknown, T10.undefined),
+  set: (_key, _value, map) => map ?? T10.unknown,
+  has: () => T10.boolean,
+  delete: () => T10.boolean
+};
+var WEAKSET_INSTANCE_METHODS = {
+  add: (_value, set) => set ?? T10.unknown,
+  has: () => T10.boolean,
+  delete: () => T10.boolean
 };
 function createWeakMapType() {
-  return T8.instanceOf("WeakMap", {});
+  return T10.instanceOf("WeakMap", {});
 }
 function createWeakSetType() {
-  return T8.instanceOf("WeakSet", {});
+  return T10.instanceOf("WeakSet", {});
 }
 
 // src/builtins/builtin-symbol.ts
-import { T as T9 } from "@nudojs/core";
+import { T as T11 } from "@nudojs/core";
 var SYMBOL_STATIC_METHODS = {
-  for: T9.symbol,
-  keyFor: T9.union(T9.string, T9.undefined)
+  for: T11.symbol,
+  keyFor: T11.union(T11.string, T11.undefined)
 };
 var SYMBOL_STATIC_PROPS = {
-  asyncIterator: T9.symbol,
-  iterator: T9.symbol,
-  toPrimitive: T9.symbol,
-  toStringTag: T9.symbol,
-  hasInstance: T9.symbol,
-  species: T9.symbol,
-  isConcatSpreadable: T9.symbol
+  asyncIterator: T11.symbol,
+  iterator: T11.symbol,
+  toPrimitive: T11.symbol,
+  toStringTag: T11.symbol,
+  hasInstance: T11.symbol,
+  species: T11.symbol,
+  isConcatSpreadable: T11.symbol
 };
 
 // src/builtins/builtin-reflect.ts
-import { T as T10 } from "@nudojs/core";
+import { T as T12 } from "@nudojs/core";
 var REFLECT_METHODS = {
-  has: () => T10.boolean,
-  get: () => T10.unknown,
-  set: () => T10.boolean,
-  deleteProperty: () => T10.boolean,
-  apply: () => T10.unknown,
-  construct: () => T10.object({}),
+  has: () => T12.boolean,
+  get: () => T12.unknown,
+  set: () => T12.boolean,
+  deleteProperty: () => T12.boolean,
+  apply: () => T12.unknown,
+  construct: () => T12.object({}),
   // Shape-aware like Object.keys: known receivers list their declared
   // own-property names (hoek's Utils.keys → clone/flatten key loops then
   // iterate concrete keys instead of a symbolic string), arrays add the
@@ -946,76 +1551,80 @@ var REFLECT_METHODS = {
     let base = target;
     while (base?.kind === "refined") base = base.base;
     if (base && (base.kind === "object" || base.kind === "instance")) {
-      return T10.tuple(Object.keys(base.properties).map((k) => T10.literal(k)));
+      return T12.tuple(Object.keys(base.properties).map((k) => T12.literal(k)));
     }
     if (base?.kind === "tuple") {
-      return T10.tuple([
-        ...base.elements.map((_, i) => T10.literal(String(i))),
-        T10.literal("length")
+      return T12.tuple([
+        ...base.elements.map((_, i) => T12.literal(String(i))),
+        T12.literal("length")
       ]);
     }
-    return T10.array(T10.string);
+    return T12.array(T12.string);
   },
-  getPrototypeOf: () => T10.union(T10.object({}), T10.null),
-  getOwnPropertyDescriptor: () => T10.union(T10.object({}), T10.undefined)
+  getPrototypeOf: () => T12.union(T12.object({}), T12.null),
+  getOwnPropertyDescriptor: () => T12.union(T12.object({}), T12.undefined)
 };
 
 // src/builtins/builtin-intl.ts
-import { T as T11 } from "@nudojs/core";
+import { T as T13 } from "@nudojs/core";
 var INTL_DATETIMEFORMAT_METHODS = {
-  format: () => T11.string
+  format: () => T13.string
 };
 var INTL_NUMBERFORMAT_METHODS = {
-  format: () => T11.string
+  format: () => T13.string
 };
 function createDateTimeFormatType() {
-  return T11.instanceOf("DateTimeFormat", {});
+  return T13.instanceOf("DateTimeFormat", {});
 }
 function createNumberFormatType() {
-  return T11.instanceOf("NumberFormat", {});
+  return T13.instanceOf("NumberFormat", {});
 }
 
-// src/evaluator.ts
+// src/builtins/builtin-static.ts
+import { T as T14, simplifyUnion as simplifyUnion7 } from "@nudojs/core";
+function hasOwnProp2(props, name) {
+  return Object.prototype.hasOwnProperty.call(props, name);
+}
 var BUILTIN_STATIC_METHODS = {
   // Node CJS 库普遍依赖的 process 全局——缺它时 process.nextTick(cb) 走
   // 未知全局 → undefined → no-method 假错（hoek wait 的 usage-site 执行）
   process: {
-    nextTick: T12.fn(["callback", "...args"], { type: "BlockStatement", body: [], directives: [] }, void 0),
-    env: T12.object({}),
-    platform: T12.string,
-    versions: T12.object({}),
-    argv: T12.array(T12.string),
-    cwd: T12.fn([], { type: "BlockStatement", body: [], directives: [] }, void 0),
-    exit: T12.fn(["code"], { type: "BlockStatement", body: [], directives: [] }, void 0),
-    hrtime: T12.fn(["time"], { type: "BlockStatement", body: [], directives: [] }, void 0),
-    stdout: T12.instanceOf("Socket"),
-    stderr: T12.instanceOf("Socket")
+    nextTick: T14.fn(["callback", "...args"], { type: "BlockStatement", body: [], directives: [] }, void 0),
+    env: T14.object({}),
+    platform: T14.string,
+    versions: T14.object({}),
+    argv: T14.array(T14.string),
+    cwd: T14.fn([], { type: "BlockStatement", body: [], directives: [] }, void 0),
+    exit: T14.fn(["code"], { type: "BlockStatement", body: [], directives: [] }, void 0),
+    hrtime: T14.fn(["time"], { type: "BlockStatement", body: [], directives: [] }, void 0),
+    stdout: T14.instanceOf("Socket"),
+    stderr: T14.instanceOf("Socket")
   },
   Date: {
-    now: T12.number,
-    parse: T12.number,
-    UTC: T12.number
+    now: T14.number,
+    parse: T14.number,
+    UTC: T14.number
   },
   Math: {
-    random: T12.number,
-    floor: T12.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
-    ceil: T12.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
-    round: T12.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
-    abs: T12.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
-    max: T12.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    min: T12.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    sqrt: T12.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
-    pow: T12.fn(["base", "exp"], { type: "BlockStatement", body: [] }, void 0),
+    random: T14.number,
+    floor: T14.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
+    ceil: T14.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
+    round: T14.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
+    abs: T14.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
+    max: T14.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    min: T14.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    sqrt: T14.fn(["x"], { type: "BlockStatement", body: [] }, void 0),
+    pow: T14.fn(["base", "exp"], { type: "BlockStatement", body: [] }, void 0),
     // Math 常量与 @nudo:env es 的 Math 定义对齐（env 绑定优先）；无 env
     // 指令时也在此解析，避免 Math.PI 走 unknown-property。
-    PI: T12.number,
-    E: T12.number,
-    LN2: T12.number,
-    LN10: T12.number,
-    LOG2E: T12.number,
-    LOG10E: T12.number,
-    SQRT2: T12.number,
-    SQRT1_2: T12.number
+    PI: T14.number,
+    E: T14.number,
+    LN2: T14.number,
+    LN10: T14.number,
+    LOG2E: T14.number,
+    LOG10E: T14.number,
+    SQRT2: T14.number,
+    SQRT1_2: T14.number
   },
   JSON: {
     // JSON.parse(literal-string): evaluate with the real JSON.parse and
@@ -1026,7 +1635,7 @@ var BUILTIN_STATIC_METHODS = {
     // the text is not valid JSON. A reviver argument also degrades: it can
     // replace every value (and the root) with an arbitrary one, so the
     // parse structure is not a sound answer (hoek/json-ext never pass one).
-    parse: T12.fnSig([T12.string], T12.unknown, T12.never, (args) => {
+    parse: T14.fnSig([T14.string], T14.unknown, T14.never, (args) => {
       const text = args[0];
       if (text?.kind !== "literal" || typeof text.value !== "string") return void 0;
       const reviver = args[1];
@@ -1037,419 +1646,132 @@ var BUILTIN_STATIC_METHODS = {
         return void 0;
       }
     }),
-    stringify: T12.string
+    stringify: T14.string
   },
   Object: {
-    keys: T12.array(T12.string),
-    values: T12.array(T12.unknown),
-    entries: T12.array(T12.tuple([T12.string, T12.unknown])),
-    assign: T12.fnSig([T12.unknown], T12.unknown, T12.never, (args) => {
+    keys: T14.array(T14.string),
+    values: T14.array(T14.unknown),
+    entries: T14.array(T14.tuple([T14.string, T14.unknown])),
+    assign: T14.fnSig([T14.unknown], T14.unknown, T14.never, (args) => {
       const target = args[0];
-      if (target?.kind !== "object") return void 0;
-      const props = { ...target.properties };
-      for (const src of args.slice(1)) {
-        if (src?.kind !== "object") return void 0;
-        Object.assign(props, src.properties);
-      }
-      return T12.object(props);
-    }),
-    // Prototype-reflection statics. getPrototypeOf maps receivers onto the
-    // cached prototype singletons so `getPrototypeOf(x) !== getPrototypeOf(y)`
-    // resolves literally; create/setPrototypeOf cover the clone-style
-    // prototype dance; getOwnPropertyDescriptor feeds descriptor.get/set
-    // branches with the property's value type.
-    getPrototypeOf: T12.fnSig([T12.unknown], T12.unknown, T12.never, (args) => protoOfValue(args[0])),
-    create: T12.fnSig([T12.unknown], T12.object({}), T12.never, () => T12.object({})),
-    setPrototypeOf: T12.fnSig([T12.unknown, T12.unknown], T12.unknown, T12.never, (args) => args[0]),
-    defineProperty: T12.fnSig([T12.unknown, T12.unknown, T12.unknown], T12.unknown, T12.never, (args) => args[0]),
-    getOwnPropertyDescriptor: T12.fnSig([T12.unknown, T12.unknown], T12.union(T12.object({}), T12.undefined), T12.never, (args) => {
-      const obj = args[0];
-      const key = args[1];
-      if (obj?.kind !== "object" && obj?.kind !== "instance") return T12.undefined;
-      if (!key) return T12.undefined;
-      if (key.kind === "literal" && typeof key.value === "string") {
-        const prop = hasOwnProp(obj.properties, key.value) ? obj.properties[key.value] : void 0;
-        if (!prop) return T12.undefined;
-        return descriptorOf(prop);
-      }
-      if (key.kind === "primitive" && key.type === "string") {
-        const props = Object.keys(obj.properties);
-        if (props.length === 0) return T12.undefined;
-        return descriptorOf(simplifyUnion4(props.map((k) => obj.properties[k])));
-      }
-      return T12.undefined;
-    })
-  },
-  Buffer: {
-    from: T12.fnSig([T12.unknown], T12.instanceOf("Buffer")),
-    alloc: T12.fnSig([T12.number], T12.instanceOf("Buffer")),
-    concat: T12.fnSig([T12.unknown], T12.instanceOf("Buffer")),
-    byteLength: T12.fnSig([T12.unknown], T12.number),
-    isEncoding: T12.fnSig([T12.unknown], T12.boolean),
-    isBuffer: T12.fnSig([T12.unknown], T12.boolean, T12.never, (args) => {
-      const lit = builtinInstanceTest(args[0], "Buffer");
-      return lit === void 0 ? void 0 : T12.literal(lit);
-    })
-  },
-  Array: {
-    isArray: T12.boolean,
-    from: T12.array(T12.unknown)
-  },
-  Number: {
-    isNaN: T12.boolean,
-    isFinite: T12.boolean,
-    parseInt: T12.number,
-    parseFloat: T12.number,
-    // Number 常量与 @nudo:env es 的 Number 定义对齐（env 绑定优先）；
-    // 均为 number（case 序列化器对非有限数返回 null，不产出字面量值）。
-    MAX_SAFE_INTEGER: T12.number,
-    MIN_SAFE_INTEGER: T12.number,
-    MAX_VALUE: T12.number,
-    MIN_VALUE: T12.number,
-    POSITIVE_INFINITY: T12.number,
-    NEGATIVE_INFINITY: T12.number,
-    NaN: T12.number,
-    EPSILON: T12.number
-  },
-  String: {
-    // fromCharCode/fromCodePoint over all-number-literal args evaluate
-    // with the real String static (hoek's escaper builds its 0x2028
-    // separator literal this way before handing it to escapeJson); any
-    // non-literal arg keeps only the string return type (the result is
-    // always a string, just not a knowable one). fromCodePoint also
-    // falls back on out-of-range literals (real RangeError → string).
-    fromCharCode: T12.fnSig([T12.number], T12.string, T12.never, (args) => {
-      const codes = literalCodeUnits(args);
-      return codes === null ? T12.string : T12.literal(String.fromCharCode(...codes));
-    }),
-    fromCodePoint: T12.fnSig([T12.number], T12.string, T12.never, (args) => {
-      const codes = literalCodeUnits(args);
-      if (codes === null) return T12.string;
-      try {
-        return T12.literal(String.fromCodePoint(...codes));
-      } catch {
-        return void 0;
-      }
-    })
-  },
-  Promise: PROMISE_STATIC_METHODS,
-  Symbol: { ...SYMBOL_STATIC_METHODS, ...SYMBOL_STATIC_PROPS },
-  Reflect: REFLECT_METHODS,
-  Intl: {
-    DateTimeFormat: T12.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-    NumberFormat: T12.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
-  },
-  parseInt: T12.number,
-  parseFloat: T12.number,
-  isNaN: T12.boolean,
-  isFinite: T12.boolean,
-  // 全局数值常量：与 @nudo:env es 的 globals 对齐（env 绑定优先）。无 env
-  // 指令时在此解析为 number——否则 Infinity/NaN 命中大写开头的未知全局
-  // 检测，触发 nudo:unknown-global 与 nudo:builtin-unknown 诊断。
-  Infinity: T12.number,
-  NaN: T12.number
-};
-function literalCodeUnits(args) {
-  const codes = [];
-  for (const a of args) {
-    if (a?.kind !== "literal" || typeof a.value !== "number") return null;
-    codes.push(a.value);
-  }
-  return codes;
-}
-function looseLiteralValue(tv) {
-  if (tv.kind === "literal") {
-    const v = tv.value;
-    if (typeof v === "number" || typeof v === "string" || typeof v === "boolean" || v === null || v === void 0) {
-      return { hit: true, v };
-    }
-  }
-  return { hit: false, v: void 0 };
-}
-var BUILTIN_ERROR_CLASSES = /* @__PURE__ */ new Set([
-  "Error",
-  "TypeError",
-  "SyntaxError",
-  "RangeError",
-  "ReferenceError",
-  "URIError",
-  "EvalError"
-]);
-var BUILTIN_PROTOTYPE_CLASSES = /* @__PURE__ */ new Set([
-  ...BUILTIN_ERROR_CLASSES,
-  "Date",
-  "Object",
-  "Map",
-  "Set",
-  "Promise",
-  "RegExp",
-  "Array",
-  "Function",
-  "String",
-  "Number",
-  "Boolean",
-  "Symbol",
-  "WeakMap",
-  "WeakSet",
-  "Buffer"
-]);
-var OBJECT_PROTOTYPE_METHODS = {
-  hasOwnProperty: T12.fnSig([T12.unknown], T12.boolean),
-  isPrototypeOf: T12.fnSig([T12.unknown], T12.boolean),
-  propertyIsEnumerable: T12.fnSig([T12.unknown], T12.boolean),
-  toString: T12.fnSig([], T12.string, T12.never, (_args, thisVal) => objectToStringBrand(thisVal)),
-  toLocaleString: T12.fnSig([], T12.string),
-  valueOf: T12.fnSig([], T12.unknown, T12.never, (_args, thisVal) => thisVal)
-};
-var BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS = {
-  Object: { ...OBJECT_PROTOTYPE_METHODS },
-  Array: {
-    push: T12.fnSig([T12.unknown], T12.number),
-    pop: T12.fnSig([], T12.unknown),
-    shift: T12.fnSig([], T12.unknown),
-    unshift: T12.fnSig([T12.unknown], T12.number),
-    slice: T12.fnSig([T12.number, T12.number], T12.array(T12.unknown)),
-    splice: T12.fnSig([T12.number, T12.number], T12.array(T12.unknown)),
-    concat: T12.fnSig([T12.unknown], T12.array(T12.unknown)),
-    join: T12.fnSig([T12.string], T12.string),
-    indexOf: T12.fnSig([T12.unknown], T12.number),
-    lastIndexOf: T12.fnSig([T12.unknown], T12.number),
-    includes: T12.fnSig([T12.unknown], T12.boolean),
-    map: T12.fnSig([T12.unknown], T12.array(T12.unknown)),
-    filter: T12.fnSig([T12.unknown], T12.array(T12.unknown)),
-    forEach: T12.fnSig([T12.unknown], T12.undefined),
-    find: T12.fnSig([T12.unknown], T12.unknown),
-    findIndex: T12.fnSig([T12.unknown], T12.number),
-    some: T12.fnSig([T12.unknown], T12.boolean),
-    every: T12.fnSig([T12.unknown], T12.boolean),
-    reduce: T12.fnSig([T12.unknown, T12.unknown], T12.unknown),
-    sort: T12.fnSig([T12.unknown], T12.array(T12.unknown)),
-    reverse: T12.fnSig([], T12.array(T12.unknown)),
-    toString: T12.fnSig([], T12.string)
-  },
-  Function: {
-    call: T12.fnSig([T12.unknown], T12.unknown),
-    apply: T12.fnSig([T12.unknown, T12.unknown], T12.unknown),
-    bind: T12.fnSig([T12.unknown], T12.unknown),
-    toString: T12.fnSig([], T12.string)
-  },
-  Map: {
-    // Impl-routed: `Map.prototype.m.call(instance)` (and direct prototype
-    // calls) consult the receiver's exact entry side table, making the
-    // hoek deepEqual reflection idioms decide literally.
-    get: T12.fnSig([T12.unknown], T12.unknown, T12.never, (args, thisVal) => MAP_INSTANCE_METHODS.get(args[0] ?? T12.unknown, thisVal ?? T12.unknown)),
-    set: T12.fnSig([T12.unknown, T12.unknown], T12.unknown, T12.never, (args, thisVal) => MAP_INSTANCE_METHODS.set(args[0] ?? T12.unknown, args[1] ?? T12.unknown, thisVal ?? T12.unknown)),
-    has: T12.fnSig([T12.unknown], T12.boolean, T12.never, (args, thisVal) => MAP_INSTANCE_METHODS.has(args[0] ?? T12.unknown, thisVal ?? T12.unknown)),
-    delete: T12.fnSig([T12.unknown], T12.boolean, T12.never, (args, thisVal) => MAP_INSTANCE_METHODS.delete(args[0] ?? T12.unknown, thisVal ?? T12.unknown)),
-    clear: T12.fnSig([], T12.undefined, T12.never, (args, thisVal) => MAP_INSTANCE_METHODS.clear(args[0] ?? T12.unknown, thisVal ?? T12.unknown)),
-    forEach: T12.fnSig([T12.unknown], T12.undefined),
-    keys: T12.fnSig([], T12.array(T12.unknown), T12.never, (_args, thisVal) => MAP_INSTANCE_METHODS.keys(thisVal ?? T12.unknown)),
-    values: T12.fnSig([], T12.array(T12.unknown), T12.never, (_args, thisVal) => MAP_INSTANCE_METHODS.values(thisVal ?? T12.unknown)),
-    entries: T12.fnSig([], T12.array(T12.tuple([T12.unknown, T12.unknown])), T12.never, (_args, thisVal) => mapEntriesIterable(thisVal ?? T12.unknown)),
-    toString: T12.fnSig([], T12.string)
-  },
-  Set: {
-    // Impl-routed like Map above (Set.prototype.values.call(s) ≡ s.values()).
-    add: T12.fnSig([T12.unknown], T12.unknown, T12.never, (args, thisVal) => SET_INSTANCE_METHODS.add(args[0] ?? T12.unknown, thisVal ?? T12.unknown)),
-    has: T12.fnSig([T12.unknown], T12.boolean, T12.never, (args, thisVal) => SET_INSTANCE_METHODS.has(args[0] ?? T12.unknown, thisVal ?? T12.unknown)),
-    delete: T12.fnSig([T12.unknown], T12.boolean, T12.never, (args, thisVal) => SET_INSTANCE_METHODS.delete(args[0] ?? T12.unknown, thisVal ?? T12.unknown)),
-    clear: T12.fnSig([], T12.undefined, T12.never, (args, thisVal) => SET_INSTANCE_METHODS.clear(args[0] ?? T12.unknown, thisVal ?? T12.unknown)),
-    forEach: T12.fnSig([T12.unknown], T12.undefined),
-    keys: T12.fnSig([], T12.array(T12.unknown), T12.never, (_args, thisVal) => SET_INSTANCE_METHODS.keys(thisVal ?? T12.unknown)),
-    values: T12.fnSig([], T12.array(T12.unknown), T12.never, (_args, thisVal) => SET_INSTANCE_METHODS.values(thisVal ?? T12.unknown)),
-    entries: T12.fnSig([], T12.array(T12.tuple([T12.unknown, T12.unknown])), T12.never, (_args, thisVal) => SET_INSTANCE_METHODS.entries(thisVal ?? T12.unknown)),
-    toString: T12.fnSig([], T12.string)
-  },
-  WeakMap: {
-    get: T12.fnSig([T12.unknown], T12.unknown),
-    set: T12.fnSig([T12.unknown, T12.unknown], T12.unknown),
-    has: T12.fnSig([T12.unknown], T12.boolean),
-    delete: T12.fnSig([T12.unknown], T12.boolean),
-    toString: T12.fnSig([], T12.string)
-  },
-  WeakSet: {
-    add: T12.fnSig([T12.unknown], T12.unknown),
-    has: T12.fnSig([T12.unknown], T12.boolean),
-    delete: T12.fnSig([T12.unknown], T12.boolean),
-    toString: T12.fnSig([], T12.string)
-  },
-  Promise: {
-    then: T12.fnSig([T12.unknown], T12.promise(T12.unknown)),
-    catch: T12.fnSig([T12.unknown], T12.promise(T12.unknown)),
-    finally: T12.fnSig([T12.unknown], T12.promise(T12.unknown)),
-    toString: T12.fnSig([], T12.string)
-  },
-  Date: {
-    getTime: T12.fnSig([], T12.number),
-    valueOf: T12.fnSig([], T12.number),
-    toISOString: T12.fnSig([], T12.string),
-    toJSON: T12.fnSig([], T12.string),
-    toLocaleString: T12.fnSig([], T12.string),
-    toString: T12.fnSig([], T12.string)
+      if (target?.kind !== "object") return void 0;
+      const props = { ...target.properties };
+      for (const src of args.slice(1)) {
+        if (src?.kind !== "object") return void 0;
+        Object.assign(props, src.properties);
+      }
+      return T14.object(props);
+    }),
+    // Prototype-reflection statics. getPrototypeOf maps receivers onto the
+    // cached prototype singletons so `getPrototypeOf(x) !== getPrototypeOf(y)`
+    // resolves literally; create/setPrototypeOf cover the clone-style
+    // prototype dance; getOwnPropertyDescriptor feeds descriptor.get/set
+    // branches with the property's value type.
+    getPrototypeOf: T14.fnSig([T14.unknown], T14.unknown, T14.never, (args) => protoOfValue(args[0])),
+    create: T14.fnSig([T14.unknown], T14.object({}), T14.never, () => T14.object({})),
+    setPrototypeOf: T14.fnSig([T14.unknown, T14.unknown], T14.unknown, T14.never, (args) => args[0]),
+    defineProperty: T14.fnSig([T14.unknown, T14.unknown, T14.unknown], T14.unknown, T14.never, (args) => args[0]),
+    getOwnPropertyDescriptor: T14.fnSig([T14.unknown, T14.unknown], T14.union(T14.object({}), T14.undefined), T14.never, (args) => {
+      const obj = args[0];
+      const key = args[1];
+      if (obj?.kind !== "object" && obj?.kind !== "instance") return T14.undefined;
+      if (!key) return T14.undefined;
+      if (key.kind === "literal" && typeof key.value === "string") {
+        const prop = hasOwnProp2(obj.properties, key.value) ? obj.properties[key.value] : void 0;
+        if (!prop) return T14.undefined;
+        return descriptorOf(prop);
+      }
+      if (key.kind === "primitive" && key.type === "string") {
+        const props = Object.keys(obj.properties);
+        if (props.length === 0) return T14.undefined;
+        return descriptorOf(simplifyUnion7(props.map((k) => obj.properties[k])));
+      }
+      return T14.undefined;
+    })
   },
-  RegExp: {
-    test: T12.fnSig([T12.string], T12.boolean),
-    exec: T12.fnSig([T12.string], T12.union(T12.object({}), T12.null)),
-    toString: T12.fnSig([], T12.string)
+  Buffer: {
+    from: T14.fnSig([T14.unknown], T14.instanceOf("Buffer")),
+    alloc: T14.fnSig([T14.number], T14.instanceOf("Buffer")),
+    concat: T14.fnSig([T14.unknown], T14.instanceOf("Buffer")),
+    byteLength: T14.fnSig([T14.unknown], T14.number),
+    isEncoding: T14.fnSig([T14.unknown], T14.boolean),
+    isBuffer: T14.fnSig([T14.unknown], T14.boolean, T14.never, (args) => {
+      const lit3 = builtinInstanceTest(args[0], "Buffer");
+      return lit3 === void 0 ? void 0 : T14.literal(lit3);
+    })
   },
-  String: {
-    charAt: T12.fnSig([T12.number], T12.string),
-    charCodeAt: T12.fnSig([T12.number], T12.number),
-    indexOf: T12.fnSig([T12.string], T12.number),
-    lastIndexOf: T12.fnSig([T12.string], T12.number),
-    includes: T12.fnSig([T12.string], T12.boolean),
-    startsWith: T12.fnSig([T12.string], T12.boolean),
-    endsWith: T12.fnSig([T12.string], T12.boolean),
-    slice: T12.fnSig([T12.number, T12.number], T12.string),
-    substring: T12.fnSig([T12.number, T12.number], T12.string),
-    toUpperCase: T12.fnSig([], T12.string),
-    toLowerCase: T12.fnSig([], T12.string),
-    trim: T12.fnSig([], T12.string),
-    replace: T12.fnSig([T12.unknown, T12.string], T12.string),
-    split: T12.fnSig([T12.string], T12.array(T12.string)),
-    toString: T12.fnSig([], T12.string),
-    valueOf: T12.fnSig([], T12.string)
+  Array: {
+    isArray: T14.boolean,
+    from: T14.array(T14.unknown)
   },
   Number: {
-    toFixed: T12.fnSig([T12.number], T12.string),
-    toPrecision: T12.fnSig([T12.number], T12.string),
-    valueOf: T12.fnSig([], T12.number),
-    toString: T12.fnSig([T12.number], T12.string)
-  },
-  Boolean: {
-    valueOf: T12.fnSig([], T12.boolean),
-    toString: T12.fnSig([], T12.string)
+    isNaN: T14.boolean,
+    isFinite: T14.boolean,
+    parseInt: T14.number,
+    parseFloat: T14.number,
+    // Number 常量与 @nudo:env es 的 Number 定义对齐（env 绑定优先）；
+    // 均为 number（case 序列化器对非有限数返回 null，不产出字面量值）。
+    MAX_SAFE_INTEGER: T14.number,
+    MIN_SAFE_INTEGER: T14.number,
+    MAX_VALUE: T14.number,
+    MIN_VALUE: T14.number,
+    POSITIVE_INFINITY: T14.number,
+    NEGATIVE_INFINITY: T14.number,
+    NaN: T14.number,
+    EPSILON: T14.number
   },
-  Symbol: {
-    toString: T12.fnSig([], T12.string),
-    valueOf: T12.fnSig([], T12.symbol)
+  String: {
+    // fromCharCode/fromCodePoint over all-number-literal args evaluate
+    // with the real String static (hoek's escaper builds its 0x2028
+    // separator literal this way before handing it to escapeJson); any
+    // non-literal arg keeps only the string return type (the result is
+    // always a string, just not a knowable one). fromCodePoint also
+    // falls back on out-of-range literals (real RangeError → string).
+    fromCharCode: T14.fnSig([T14.number], T14.string, T14.never, (args) => {
+      const codes = literalCodeUnits(args);
+      return codes === null ? T14.string : T14.literal(String.fromCharCode(...codes));
+    }),
+    fromCodePoint: T14.fnSig([T14.number], T14.string, T14.never, (args) => {
+      const codes = literalCodeUnits(args);
+      if (codes === null) return T14.string;
+      try {
+        return T14.literal(String.fromCodePoint(...codes));
+      } catch {
+        return void 0;
+      }
+    })
   },
-  Buffer: {
-    equals: T12.fnSig([T12.unknown], T12.boolean),
-    compare: T12.fnSig([T12.unknown], T12.number),
-    toString: T12.fnSig([T12.unknown], T12.string),
-    toJSON: T12.fnSig([], T12.unknown)
+  Promise: PROMISE_STATIC_METHODS,
+  Symbol: { ...SYMBOL_STATIC_METHODS, ...SYMBOL_STATIC_PROPS },
+  Reflect: REFLECT_METHODS,
+  Intl: {
+    DateTimeFormat: T14.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+    NumberFormat: T14.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
   },
-  Error: {
-    toString: T12.fnSig([], T12.string)
-  }
+  parseInt: T14.number,
+  parseFloat: T14.number,
+  isNaN: T14.boolean,
+  isFinite: T14.boolean,
+  // 全局数值常量：与 @nudo:env es 的 globals 对齐（env 绑定优先）。无 env
+  // 指令时在此解析为 number——否则 Infinity/NaN 命中大写开头的未知全局
+  // 检测，触发 nudo:unknown-global 与 nudo:builtin-unknown 诊断。
+  Infinity: T14.number,
+  NaN: T14.number
 };
-var _builtinClassValues = /* @__PURE__ */ new Map();
-function builtinClassValue(name) {
-  let v = _builtinClassValues.get(name);
-  if (v === void 0) {
-    v = T12.object({});
-    v._builtinName = name;
-    _builtinClassValues.set(name, v);
-  }
-  return v;
-}
-function memberMayExistOn(tv, propName) {
-  if (tv.kind === "primitive" || tv.kind === "literal") {
-    return wrapperPrototypeMember(tv, propName) !== void 0;
-  }
-  if (tv.kind === "instance") {
-    const className = tv.className;
-    const table = hasOwnProp(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className] : BUILTIN_ERROR_CLASSES.has(className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Error : void 0;
-    if (table && hasOwnProp(table, propName)) return true;
-    return true;
-  }
-  return false;
-}
-function wrapperPrototypeMember(obj, propName) {
-  let className;
-  if (obj.kind === "primitive") {
-    className = obj.type === "bigint" ? void 0 : obj.type[0].toUpperCase() + obj.type.slice(1);
-  } else if (obj.kind === "literal") {
-    if (typeof obj.value === "string") className = "String";
-    else if (typeof obj.value === "number") className = "Number";
-    else if (typeof obj.value === "boolean") className = "Boolean";
-  }
-  if (!className) return void 0;
-  if (propName === "constructor") return builtinClassValue(className);
-  const table = BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className];
-  if (table && hasOwnProp(table, propName)) return table[propName];
-  return void 0;
-}
-var BUILTIN_PROTOTYPE_SINGLETONS = /* @__PURE__ */ new Map();
-function builtinPrototype(className) {
-  let proto = BUILTIN_PROTOTYPE_SINGLETONS.get(className);
-  if (!proto) {
-    const methods = hasOwnProp(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className] : BUILTIN_ERROR_CLASSES.has(className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Error : {};
-    proto = T12.instanceOf(className, { ...methods });
-    proto._builtinProto = className;
-    BUILTIN_PROTOTYPE_SINGLETONS.set(className, proto);
-  }
-  return proto;
-}
-function objectToStringBrand(v) {
-  if (!v) return void 0;
-  if (v.kind === "union") {
-    const parts = v.members.map((m) => objectToStringBrand(m));
-    if (parts.some((p) => p === void 0)) return void 0;
-    return simplifyUnion4(parts);
-  }
-  let base = v;
-  while (base.kind === "refined") base = base.base;
-  switch (base.kind) {
-    case "object":
-      return T12.literal("[object Object]");
-    case "array":
-    case "tuple":
-      return T12.literal("[object Array]");
-    case "function":
-      return T12.literal("[object Function]");
-    case "promise":
-      return T12.literal("[object Promise]");
-    case "instance":
-      return T12.literal(`[object ${base.className}]`);
-    case "literal": {
-      if (base.value === null) return T12.literal("[object Null]");
-      if (base.value === void 0) return T12.literal("[object Undefined]");
-      const t = typeof base.value;
-      return T12.literal(`[object ${t === "number" ? "Number" : t === "string" ? "String" : "Boolean"}]`);
-    }
-    case "primitive": {
-      const brands = {
-        number: "Number",
-        string: "String",
-        boolean: "Boolean",
-        bigint: "BigInt",
-        symbol: "Symbol"
-      };
-      return T12.literal(`[object ${brands[base.type] ?? "Object"}]`);
-    }
-    default:
-      return void 0;
-  }
-}
-function protoOfValue(v) {
-  if (!v) return T12.unknown;
-  if (v.kind === "union") return simplifyUnion4(v.members.map((m) => protoOfValue(m)));
-  let base = v;
-  while (base.kind === "refined") base = base.base;
-  switch (base.kind) {
-    case "object":
-      return builtinPrototype("Object");
-    case "array":
-    case "tuple":
-      return builtinPrototype("Array");
-    case "function":
-      return builtinPrototype("Function");
-    case "promise":
-      return builtinPrototype("Promise");
-    case "instance":
-      return builtinPrototype(base.className);
-    default:
-      return T12.unknown;
+function literalCodeUnits(args) {
+  const codes = [];
+  for (const a of args) {
+    if (a?.kind !== "literal" || typeof a.value !== "number") return null;
+    codes.push(a.value);
   }
+  return codes;
 }
 function descriptorOf(prop) {
-  return T12.object({
+  return T14.object({
     value: prop,
-    writable: T12.boolean,
-    enumerable: T12.boolean,
-    configurable: T12.boolean
+    writable: T14.boolean,
+    enumerable: T14.boolean,
+    configurable: T14.boolean
   });
 }
 function builtinInstanceTest(v, className) {
@@ -1473,6 +1795,55 @@ function builtinInstanceTest(v, className) {
       return void 0;
   }
 }
+function jsonToTypeValue(v) {
+  if (v === null) return T14.literal(null);
+  if (typeof v === "string") return T14.literal(v);
+  if (typeof v === "number") return T14.literal(v);
+  if (typeof v === "boolean") return T14.literal(v);
+  if (Array.isArray(v)) return T14.tuple(v.map(jsonToTypeValue));
+  if (typeof v === "object") {
+    const props = {};
+    for (const [k, val] of Object.entries(v)) {
+      Object.defineProperty(props, k, {
+        value: jsonToTypeValue(val),
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+    return T14.object(props);
+  }
+  return T14.unknown;
+}
+
+// src/evaluator.ts
+function memberMayExistOn(tv, propName) {
+  if (tv.kind === "primitive" || tv.kind === "literal") {
+    return wrapperPrototypeMember(tv, propName) !== void 0;
+  }
+  if (tv.kind === "instance") {
+    const className = tv.className;
+    const table = hasOwnProp3(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className] : BUILTIN_ERROR_CLASSES.has(className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Error : void 0;
+    if (table && hasOwnProp3(table, propName)) return true;
+    return true;
+  }
+  return false;
+}
+function wrapperPrototypeMember(obj, propName) {
+  let className;
+  if (obj.kind === "primitive") {
+    className = obj.type === "bigint" ? void 0 : obj.type[0].toUpperCase() + obj.type.slice(1);
+  } else if (obj.kind === "literal") {
+    if (typeof obj.value === "string") className = "String";
+    else if (typeof obj.value === "number") className = "Number";
+    else if (typeof obj.value === "boolean") className = "Boolean";
+  }
+  if (!className) return void 0;
+  if (propName === "constructor") return builtinClassValue(className);
+  const table = BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className];
+  if (table && hasOwnProp3(table, propName)) return table[propName];
+  return void 0;
+}
 function arrayIsArrayLiteral(v) {
   let base = v;
   while (base.kind === "refined") base = base.base;
@@ -1522,17 +1893,24 @@ function definiteBoolean(tv) {
       return null;
   }
 }
+function joinOrUnion(a, b) {
+  if (a.kind === "object" && b.kind === "object") {
+    const joined = tryAbsJoinObjects(a, b);
+    if (joined) return joined;
+  }
+  return simplifyUnion8([a, b]);
+}
 function bindObjectProtoMethod(fn, receiver) {
   const sig = getFnSig(fn);
   if (!sig?.impl) return fn;
-  return T12.fnSig(sig.paramTypes, sig.returnType, sig.throwsType, (args, thisVal) => sig.impl(args, thisVal ?? receiver));
+  return T15.fnSig(sig.paramTypes, sig.returnType, sig.throwsType, (args, thisVal) => sig.impl(args, thisVal ?? receiver));
 }
 function valueOfBinding(receiver) {
   switch (receiver.kind) {
     case "literal": {
       const v = receiver.value;
       if (v === null || v === void 0) {
-        return T12.fnSig([], T12.never, T12.instanceOf("TypeError"));
+        return T15.fnSig([], T15.never, T15.instanceOf("TypeError"));
       }
       return bindObjectProtoMethod(OBJECT_PROTOTYPE_METHODS["valueOf"], receiver);
     }
@@ -1592,7 +1970,7 @@ var _wellKnownSymbols = /* @__PURE__ */ new Map();
 function wellKnownSymbol(name) {
   let v = _wellKnownSymbols.get(name);
   if (v === void 0) {
-    v = { ...T12.symbol, _symbolName: name };
+    v = { ...T15.symbol, _symbolName: name };
     _wellKnownSymbols.set(name, v);
   }
   return v;
@@ -1631,15 +2009,15 @@ function evaluateInMember(key, container) {
   while (k.kind === "refined") k = k.base;
   let c = container;
   while (c.kind === "refined") c = c.base;
-  if (c.kind === "unknown") return T12.unknown;
+  if (c.kind === "unknown") return T15.unknown;
   const symName = wellKnownSymbolName(k);
   if (symName !== void 0) {
     if (symName === "iterator") {
       const iter = iteratorInReceiver(c);
-      return iter === void 0 ? T12.boolean : T12.literal(iter);
+      return iter === void 0 ? T15.boolean : T15.literal(iter);
     }
-    if (c.kind === "instance" && !BUILTIN_PROTOTYPE_CLASSES.has(c.className)) return T12.boolean;
-    return T12.literal(false);
+    if (c.kind === "instance" && !BUILTIN_PROTOTYPE_CLASSES.has(c.className)) return T15.boolean;
+    return T15.literal(false);
   }
   const strKey = k.kind === "literal" && typeof k.value === "string" ? k.value : void 0;
   if (strKey === void 0) {
@@ -1650,54 +2028,54 @@ function evaluateInMember(key, container) {
       case "function":
       case "array":
       case "tuple":
-        return T12.boolean;
+        return T15.boolean;
       case "literal":
       case "primitive":
-        return T12.literal(false);
+        return T15.literal(false);
       default:
-        return T12.unknown;
+        return T15.unknown;
     }
   }
   const isArrayIndex = (s) => /^\d+$/.test(s);
   switch (c.kind) {
     case "object":
-      return T12.literal(hasOwnProp(c.properties, strKey) || hasOwnProp(OBJECT_PROTOTYPE_METHODS, strKey));
+      return T15.literal(hasOwnProp3(c.properties, strKey) || hasOwnProp3(OBJECT_PROTOTYPE_METHODS, strKey));
     case "tuple":
-      if (strKey === "length") return T12.literal(true);
-      if (isArrayIndex(strKey)) return T12.literal(Number(strKey) < c.elements.length);
-      return T12.literal(
-        hasOwnProp(OBJECT_PROTOTYPE_METHODS, strKey) || hasOwnProp(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Array, strKey)
+      if (strKey === "length") return T15.literal(true);
+      if (isArrayIndex(strKey)) return T15.literal(Number(strKey) < c.elements.length);
+      return T15.literal(
+        hasOwnProp3(OBJECT_PROTOTYPE_METHODS, strKey) || hasOwnProp3(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Array, strKey)
       );
     case "array":
-      return T12.literal(
-        strKey === "length" || isArrayIndex(strKey) || hasOwnProp(OBJECT_PROTOTYPE_METHODS, strKey) || hasOwnProp(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Array, strKey)
+      return T15.literal(
+        strKey === "length" || isArrayIndex(strKey) || hasOwnProp3(OBJECT_PROTOTYPE_METHODS, strKey) || hasOwnProp3(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Array, strKey)
       );
     case "instance": {
-      if (hasOwnProp(c.properties, strKey)) return T12.literal(true);
-      if (hasOwnProp(OBJECT_PROTOTYPE_METHODS, strKey)) return T12.literal(true);
-      const approx = hasOwnProp(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, c.className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[c.className] : void 0;
-      if (approx && hasOwnProp(approx, strKey)) return T12.literal(true);
-      if ((c.className === "Set" || c.className === "Map") && strKey === "size") return T12.literal(true);
-      return T12.literal(false);
+      if (hasOwnProp3(c.properties, strKey)) return T15.literal(true);
+      if (hasOwnProp3(OBJECT_PROTOTYPE_METHODS, strKey)) return T15.literal(true);
+      const approx = hasOwnProp3(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, c.className) ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[c.className] : void 0;
+      if (approx && hasOwnProp3(approx, strKey)) return T15.literal(true);
+      if ((c.className === "Set" || c.className === "Map") && strKey === "size") return T15.literal(true);
+      return T15.literal(false);
     }
     case "function":
-      return T12.literal(
+      return T15.literal(
         strKey === "prototype" || strKey === "name" || strKey === "length" || strKey === "call" || strKey === "apply" || strKey === "bind" || strKey === "toString"
       );
     case "promise":
-      return T12.literal(
-        strKey === "then" || strKey === "catch" || strKey === "finally" || hasOwnProp(OBJECT_PROTOTYPE_METHODS, strKey)
+      return T15.literal(
+        strKey === "then" || strKey === "catch" || strKey === "finally" || hasOwnProp3(OBJECT_PROTOTYPE_METHODS, strKey)
       );
     case "literal":
       if (typeof c.value === "string") {
-        return T12.literal(strKey === "length" || isArrayIndex(strKey) && Number(strKey) < c.value.length);
+        return T15.literal(strKey === "length" || isArrayIndex(strKey) && Number(strKey) < c.value.length);
       }
-      return T12.literal(false);
+      return T15.literal(false);
     case "primitive":
-      if (c.type === "string") return T12.literal(strKey === "length" || isArrayIndex(strKey));
-      return T12.literal(false);
+      if (c.type === "string") return T15.literal(strKey === "length" || isArrayIndex(strKey));
+      return T15.literal(false);
     default:
-      return T12.boolean;
+      return T15.boolean;
   }
 }
 var _currentSource = "";
@@ -1746,10 +2124,10 @@ function isThrow(v) {
 }
 var LOOP_SIGNAL_KIND = Symbol("LoopSignalKind");
 function makeBreak() {
-  return { [THROW_SIGNAL]: true, [LOOP_SIGNAL_KIND]: "break", thrown: T12.never };
+  return { [THROW_SIGNAL]: true, [LOOP_SIGNAL_KIND]: "break", thrown: T15.never };
 }
 function makeContinue() {
-  return { [THROW_SIGNAL]: true, [LOOP_SIGNAL_KIND]: "continue", thrown: T12.never };
+  return { [THROW_SIGNAL]: true, [LOOP_SIGNAL_KIND]: "continue", thrown: T15.never };
 }
 function loopSignalKind(v) {
   if (typeof v !== "object" || v === null) return null;
@@ -1871,17 +2249,17 @@ function tagModuleExports(env, filePath) {
     tagExport(v, filePath, name);
   }
 }
-var _cjsRequireValue = T12.fn(["specifier"], { type: "BlockStatement", body: [] }, void 0);
+var _cjsRequireValue = T15.fn(["specifier"], { type: "BlockStatement", body: [] }, void 0);
 function bindCommonJsGlobals(env) {
   if (env.has("module")) return;
-  const exportsObj = T12.object({});
+  const exportsObj = T15.object({});
   exportsObj.__cjsExportsRoot = true;
-  const moduleObj = T12.object({ exports: exportsObj });
+  const moduleObj = T15.object({ exports: exportsObj });
   env.bind("exports", exportsObj);
   env.bind("module", moduleObj);
   env.bind("require", _cjsRequireValue);
-  env.bind("__dirname", T12.string);
-  env.bind("__filename", T12.string);
+  env.bind("__dirname", T15.string);
+  env.bind("__filename", T15.string);
 }
 function tagCommonJsExports(env, filePath) {
   if (!env.has("module")) return;
@@ -1932,6 +2310,11 @@ var _provenanceEnabled = false;
 function setProvenanceTracking(enabled) {
   _provenanceEnabled = enabled;
 }
+function copyOrigin(from, to) {
+  if (!_provenanceEnabled || !from || !to) return;
+  const o = _originMap.get(from);
+  if (o) _originMap.set(to, o);
+}
 function extractOrigin(tv) {
   if (!_provenanceEnabled || !tv) return void 0;
   const direct = _originMap.get(tv);
@@ -1949,7 +2332,7 @@ function extractOrigin(tv) {
   }
   return void 0;
 }
-function hasOwnProp(props, name) {
+function hasOwnProp3(props, name) {
   return Object.prototype.hasOwnProperty.call(props, name);
 }
 function recordUnknown(r) {
@@ -1964,7 +2347,7 @@ function recordUnknown(r) {
 }
 function distributeOverUnion(tv, fn) {
   if (tv.kind === "union") {
-    return simplifyUnion4(tv.members.map(fn));
+    return simplifyUnion8(tv.members.map(fn));
   }
   return fn(tv);
 }
@@ -2020,19 +2403,19 @@ function keySetStructureKey(tv) {
 }
 function objectKeySetAccess(obj) {
   const keys = Object.keys(obj.properties);
-  if (keys.length === 0) return T12.undefined;
-  if (keys.length > MAX_KEYSET_PROPS) return T12.unknown;
+  if (keys.length === 0) return T15.undefined;
+  if (keys.length > MAX_KEYSET_PROPS) return T15.unknown;
   const values = keys.map((k) => obj.properties[k]);
-  if (values.every((v) => v.kind === "unknown")) return T12.unknown;
+  if (values.every((v) => v.kind === "unknown")) return T15.unknown;
   const firstKey = keySetStructureKey(values[0]);
   if (values.every((v) => keySetStructureKey(v) === firstKey)) {
     return values[0];
   }
   if (values.every((v) => v.kind === "function") && values.length > MAX_KEYSET_TABLE_FNS) {
-    return T12.unknown;
+    return T15.unknown;
   }
-  const union = simplifyUnion4(values);
-  if (union.kind === "union" && union.members.length > MAX_KEYSET_MEMBERS) return T12.unknown;
+  const union = simplifyUnion8(values);
+  if (union.kind === "union" && union.members.length > MAX_KEYSET_MEMBERS) return T15.unknown;
   return union;
 }
 function isDynamicStringKey(propVal) {
@@ -2055,13 +2438,13 @@ function unionOfLiteralKind(tv, pred) {
 function computedMemberOnMember(obj, propVal, markMiss) {
   if (obj.kind === "object") {
     if (propVal.kind === "literal" && typeof propVal.value === "string") {
-      return (hasOwnProp(obj.properties, propVal.value) ? obj.properties[propVal.value] : void 0) ?? T12.undefined;
+      return (hasOwnProp3(obj.properties, propVal.value) ? obj.properties[propVal.value] : void 0) ?? T15.undefined;
     }
     if (unionOfLiteralKind(propVal, (v) => typeof v === "string")) {
-      return simplifyUnion4(
+      return simplifyUnion8(
         propVal.members.map(
           (m) => m.value
-        ).map((k) => (hasOwnProp(obj.properties, k) ? obj.properties[k] : void 0) ?? T12.undefined)
+        ).map((k) => (hasOwnProp3(obj.properties, k) ? obj.properties[k] : void 0) ?? T15.undefined)
       );
     }
     if (isDynamicStringKey(propVal)) {
@@ -2070,40 +2453,40 @@ function computedMemberOnMember(obj, propVal, markMiss) {
     if (propVal.kind === "literal" && typeof propVal.value === "string") {
       markMiss();
     }
-    return T12.unknown;
+    return T15.unknown;
   }
   if (obj.kind === "array" || obj.kind === "tuple") {
     if (propVal.kind === "literal" && typeof propVal.value === "number") {
-      if (obj.kind === "tuple") return obj.elements[propVal.value] ?? T12.undefined;
+      if (obj.kind === "tuple") return obj.elements[propVal.value] ?? T15.undefined;
       return obj.element;
     }
     if (propVal.kind === "literal" && typeof propVal.value === "string") {
-      return T12.undefined;
+      return T15.undefined;
     }
     if (unionOfLiteralKind(propVal, (v) => typeof v === "number")) {
       const indices = propVal.members.map(
         (m) => m.value
       );
       if (obj.kind === "tuple") {
-        return simplifyUnion4(indices.map((i) => obj.elements[i] ?? T12.undefined));
+        return simplifyUnion8(indices.map((i) => obj.elements[i] ?? T15.undefined));
       }
       return obj.element;
     }
     if (isDynamicNumberKey(propVal)) {
       if (obj.kind === "tuple") {
-        return obj.elements.length > 0 ? simplifyUnion4(obj.elements) : T12.undefined;
+        return obj.elements.length > 0 ? simplifyUnion8(obj.elements) : T15.undefined;
       }
       return obj.element;
     }
-    return T12.unknown;
+    return T15.unknown;
   }
   if (obj.kind === "instance" && isDynamicStringKey(propVal)) {
-    return T12.undefined;
+    return T15.undefined;
   }
   if (propVal.kind === "literal" && typeof propVal.value === "string") {
     markMiss();
   }
-  return T12.unknown;
+  return T15.unknown;
 }
 function evaluateComputedMemberAccess(objVal, propVal, node) {
   let propMissed = false;
@@ -2124,24 +2507,6 @@ function evaluateComputedMemberAccess(objVal, propVal, node) {
   }
   return result;
 }
-var MAX_UNION_PRODUCT = 50;
-function distributeBinaryOverUnion(left, right, fn) {
-  if (left.kind === "union" && right.kind === "union") {
-    if (left.members.length * right.members.length > MAX_UNION_PRODUCT) {
-      return T12.unknown;
-    }
-    return simplifyUnion4(
-      left.members.flatMap((l) => right.members.map((r) => fn(l, r)))
-    );
-  }
-  if (left.kind === "union") {
-    return simplifyUnion4(left.members.map((l) => fn(l, right)));
-  }
-  if (right.kind === "union") {
-    return simplifyUnion4(right.members.map((r) => fn(left, r)));
-  }
-  return fn(left, right);
-}
 var _unreachableRanges = [];
 function collectUnreachable(stmts, fromIndex) {
   for (let j = fromIndex; j < stmts.length; j++) {
@@ -2157,7 +2522,7 @@ function collectUnreachable(stmts, fromIndex) {
 function evaluateStatements(stmts, env) {
   const returnValues = [];
   let currentEnv = env;
-  let lastValue = T12.undefined;
+  let lastValue = T15.undefined;
   for (let i = 0; i < stmts.length; i++) {
     const stmt = stmts[i];
     const inlineDirectives = extractInlineDirectives(stmt);
@@ -2177,7 +2542,7 @@ function evaluateStatements(stmts, env) {
     if (isReturn(result)) {
       returnValues.push(result.value);
       collectUnreachable(stmts, i + 1);
-      return makeReturn(simplifyUnion4(returnValues));
+      return makeReturn(simplifyUnion8(returnValues));
     }
     if (isBranch(result)) {
       returnValues.push(result.returnedValue);
@@ -2187,7 +2552,7 @@ function evaluateStatements(stmts, env) {
     lastValue = result;
   }
   if (returnValues.length > 0) {
-    return makeBranch(simplifyUnion4(returnValues), currentEnv);
+    return makeBranch(simplifyUnion8(returnValues), currentEnv);
   }
   return lastValue;
 }
@@ -2229,18 +2594,18 @@ function evaluateNode(node, env) {
       if (_activeAsOverride) return _activeAsOverride;
       return evaluate(node.expression, env);
     case "NumericLiteral":
-      return T12.literal(node.value);
+      return T15.literal(node.value);
     case "StringLiteral":
-      return T12.literal(node.value);
+      return T15.literal(node.value);
     case "BooleanLiteral":
-      return T12.literal(node.value);
+      return T15.literal(node.value);
     case "NullLiteral":
-      return T12.null;
+      return T15.null;
     case "RegExpLiteral":
       return createRegExpType();
     case "Identifier": {
-      if (node.name === "undefined") return T12.undefined;
-      if (hasOwnProp(BUILTIN_STATIC_METHODS, node.name) && !env.has(node.name)) {
+      if (node.name === "undefined") return T15.undefined;
+      if (hasOwnProp3(BUILTIN_STATIC_METHODS, node.name) && !env.has(node.name)) {
         const builtin = BUILTIN_STATIC_METHODS[node.name];
         if (typeof builtin === "object" && builtin !== null && !("kind" in builtin)) {
           return builtinClassValue(node.name);
@@ -2260,9 +2625,9 @@ function evaluateNode(node, env) {
           loc: node.loc,
           reason: `unknown global identifier '${node.name}'`
         });
-        return T12.unknown;
+        return T15.unknown;
       }
-      if (!env.has(node.name) && hasOwnProp(OBJECT_PROTOTYPE_METHODS, node.name)) {
+      if (!env.has(node.name) && hasOwnProp3(OBJECT_PROTOTYPE_METHODS, node.name)) {
         return OBJECT_PROTOTYPE_METHODS[node.name];
       }
       return env.lookup(node.name);
@@ -2270,19 +2635,19 @@ function evaluateNode(node, env) {
     case "ThisExpression": {
       const thisVal = env.lookup("this");
       if (thisVal === void 0 || thisVal.kind === "literal" && thisVal.value === void 0) {
-        return T12.unknown;
+        return T15.unknown;
       }
       return thisVal;
     }
     case "TemplateLiteral": {
       if (node.expressions.length === 0 && node.quasis.length === 1) {
-        return T12.literal(node.quasis[0].value.cooked ?? node.quasis[0].value.raw);
+        return T15.literal(node.quasis[0].value.cooked ?? node.quasis[0].value.raw);
       }
       const parts = [];
       for (let i = 0; i < node.quasis.length; i++) {
         const quasi = node.quasis[i];
         const raw = quasi.value.cooked ?? quasi.value.raw;
-        if (raw) parts.push(T12.literal(raw));
+        if (raw) parts.push(T15.literal(raw));
         if (i < node.expressions.length) {
           const exprVal = evaluate(node.expressions[i], env);
           if (isReturn(exprVal) || isBranch(exprVal) || isThrow(exprVal)) return exprVal;
@@ -2293,7 +2658,7 @@ function evaluateNode(node, env) {
         (p) => p.kind === "literal" && (typeof p.value === "string" || typeof p.value === "number")
       );
       if (allLiteral) {
-        return T12.literal(
+        return T15.literal(
           parts.map((p) => p.kind === "literal" ? String(p.value) : "").join("")
         );
       }
@@ -2313,45 +2678,30 @@ function evaluateNode(node, env) {
       if (node.operator === "===" || node.operator === "!==") {
         const identity = builtinProtoIdentityEq(leftVal, rightVal);
         if (identity !== null) {
-          return T12.literal(node.operator === "===" ? identity : !identity);
+          return T15.literal(node.operator === "===" ? identity : !identity);
         }
         const classIdentity = builtinClassIdentityEq(leftVal, rightVal);
         if (classIdentity !== null) {
-          return T12.literal(node.operator === "===" ? classIdentity : !classIdentity);
+          return T15.literal(node.operator === "===" ? classIdentity : !classIdentity);
         }
       }
-      if (node.operator === "==" || node.operator === "!=") {
-        const eq = node.operator === "==";
-        return distributeBinaryOverUnion(leftVal, rightVal, (l, r) => {
-          const lv = looseLiteralValue(l);
-          const rv = looseLiteralValue(r);
-          if (lv.hit && rv.hit) return T12.literal(eq ? lv.v == rv.v : lv.v != rv.v);
-          return T12.boolean;
-        });
-      }
-      return distributeBinaryOverUnion(
-        leftVal,
-        rightVal,
-        (l, r) => dispatchBinaryOp(node.operator, l, r)
-      );
+      const bin = evalBinaryValue(node.operator, leftVal, rightVal);
+      if (bin !== void 0) return bin;
+      return T15.unknown;
     }
     case "UnaryExpression": {
       const argVal = evaluate(node.argument, env);
       if (isReturn(argVal) || isBranch(argVal) || isThrow(argVal)) return argVal;
-      if (node.operator === "typeof") {
-        return distributeOverUnion(argVal, (v) => Ops.typeof_(v));
-      }
+      const unary = tryAbsUnary(node.operator, argVal);
+      if (unary !== void 0) return unary;
       if (node.operator === "!") {
         return distributeOverUnion(argVal, (v) => {
           const decided = definiteBoolean(v);
-          if (decided !== null) return T12.literal(!decided);
+          if (decided !== null) return T15.literal(!decided);
           return Ops.not(v);
         });
       }
-      if (node.operator === "-") {
-        return distributeOverUnion(argVal, (v) => Ops.neg(v));
-      }
-      return T12.unknown;
+      return T15.unknown;
     }
     case "LogicalExpression": {
       const leftVal = evaluate(node.left, env);
@@ -2369,8 +2719,8 @@ function evaluateNode(node, env) {
         }
         if (leftTruthy === false) return leftVal;
         const rv = evaluate(node.right, env);
-        const rightTV = isReturn(rv) || isBranch(rv) || isThrow(rv) ? T12.unknown : rv;
-        return simplifyUnion4([leftVal, rightTV]);
+        const rightTV = isReturn(rv) || isBranch(rv) || isThrow(rv) ? T15.unknown : rv;
+        return simplifyUnion8([leftVal, rightTV]);
       }
       if (node.operator === "||") {
         if (leftVal.kind === "literal" && leftVal.value) return leftVal;
@@ -2385,8 +2735,8 @@ function evaluateNode(node, env) {
           return isReturn(rv2) || isBranch(rv2) || isThrow(rv2) ? rv2 : rv2;
         }
         const rv = evaluate(node.right, env);
-        const rightTV = isReturn(rv) || isBranch(rv) || isThrow(rv) ? T12.unknown : rv;
-        return simplifyUnion4([leftVal, rightTV]);
+        const rightTV = isReturn(rv) || isBranch(rv) || isThrow(rv) ? T15.unknown : rv;
+        return simplifyUnion8([leftVal, rightTV]);
       }
       if (node.operator === "??") {
         if (leftVal.kind === "literal" && leftVal.value !== null && leftVal.value !== void 0) {
@@ -2404,10 +2754,10 @@ function evaluateNode(node, env) {
           return narrowedLeft;
         }
         const rv = evaluate(node.right, env);
-        const rightTV = isReturn(rv) || isBranch(rv) || isThrow(rv) ? T12.unknown : rv;
+        const rightTV = isReturn(rv) || isBranch(rv) || isThrow(rv) ? T15.unknown : rv;
         return rightTV;
       }
-      return T12.unknown;
+      return T15.unknown;
     }
     case "ConditionalExpression": {
       const test = node.test;
@@ -2423,15 +2773,16 @@ function evaluateNode(node, env) {
       }
       const cResult = evaluate(node.consequent, trueEnv);
       const aResult = evaluate(node.alternate, falseEnv);
-      const cVal = isReturn(cResult) ? cResult.value : isBranch(cResult) ? cResult.returnedValue : isThrow(cResult) ? T12.never : cResult;
-      const aVal = isReturn(aResult) ? aResult.value : isBranch(aResult) ? aResult.returnedValue : isThrow(aResult) ? T12.never : aResult;
-      return simplifyUnion4([cVal, aVal]);
+      const cVal = isReturn(cResult) ? cResult.value : isBranch(cResult) ? cResult.returnedValue : isThrow(cResult) ? T15.never : cResult;
+      const aVal = isReturn(aResult) ? aResult.value : isBranch(aResult) ? aResult.returnedValue : isThrow(aResult) ? T15.never : aResult;
+      return joinOrUnion(cVal, aVal);
     }
     case "IfStatement": {
       const test = node.test;
       const [trueEnv, falseEnv] = narrow(test, env);
       const testVal = evaluate(test, env);
       if (isReturn(testVal) || isBranch(testVal) || isThrow(testVal)) return testVal;
+      const phis = phiFromTest(test);
       if (testVal.kind === "literal") {
         if (testVal.value) {
           if (node.alternate?.loc) {
@@ -2440,7 +2791,12 @@ function evaluateNode(node, env) {
               end: { line: node.alternate.loc.end.line, column: node.alternate.loc.end.column }
             });
           }
-          return evaluate(node.consequent, trueEnv);
+          pushPhi(combinePhi(currentPhi(), phis.whenTrue));
+          try {
+            return evaluate(node.consequent, trueEnv);
+          } finally {
+            popPhi();
+          }
         }
         if (node.consequent.loc) {
           _unreachableRanges.push({
@@ -2448,17 +2804,46 @@ function evaluateNode(node, env) {
             end: { line: node.consequent.loc.end.line, column: node.consequent.loc.end.column }
           });
         }
-        return node.alternate ? evaluate(node.alternate, falseEnv) : T12.undefined;
+        if (!node.alternate) return T15.undefined;
+        pushPhi(combinePhi(currentPhi(), phis.whenFalse));
+        try {
+          return evaluate(node.alternate, falseEnv);
+        } finally {
+          popPhi();
+        }
       }
       const decided = definiteBoolean(testVal);
       if (decided !== null) {
         if (decided) {
-          return evaluate(node.consequent, trueEnv);
+          pushPhi(combinePhi(currentPhi(), phis.whenTrue));
+          try {
+            return evaluate(node.consequent, trueEnv);
+          } finally {
+            popPhi();
+          }
         }
-        return node.alternate ? evaluate(node.alternate, falseEnv) : T12.undefined;
+        if (!node.alternate) return T15.undefined;
+        pushPhi(combinePhi(currentPhi(), phis.whenFalse));
+        try {
+          return evaluate(node.alternate, falseEnv);
+        } finally {
+          popPhi();
+        }
+      }
+      pushPhi(combinePhi(currentPhi(), phis.whenTrue));
+      let consequentResult;
+      try {
+        consequentResult = evaluate(node.consequent, trueEnv);
+      } finally {
+        popPhi();
+      }
+      pushPhi(combinePhi(currentPhi(), phis.whenFalse));
+      let alternateResult = null;
+      try {
+        alternateResult = node.alternate ? evaluate(node.alternate, falseEnv) : null;
+      } finally {
+        popPhi();
       }
-      const consequentResult = evaluate(node.consequent, trueEnv);
-      const alternateResult = node.alternate ? evaluate(node.alternate, falseEnv) : null;
       const cReturns = isReturn(consequentResult);
       const cBranches = isBranch(consequentResult);
       const cThrows = isThrow(consequentResult);
@@ -2469,7 +2854,7 @@ function evaluateNode(node, env) {
         return consequentResult;
       }
       if (cThrows && !node.alternate) {
-        return makeBranch(T12.never, falseEnv);
+        return makeBranch(T15.never, falseEnv);
       }
       if (cThrows) {
         const aVal2 = aReturns ? alternateResult.value : aBranches ? alternateResult.returnedValue : alternateResult;
@@ -2482,14 +2867,14 @@ function evaluateNode(node, env) {
       const cVal = cReturns ? consequentResult.value : cBranches ? consequentResult.returnedValue : consequentResult;
       const aVal = aReturns ? alternateResult.value : aBranches ? alternateResult.returnedValue : alternateResult;
       if (cReturns && aReturns) {
-        return makeReturn(simplifyUnion4([cVal, aVal]));
+        return makeReturn(joinOrUnion(cVal, aVal));
       }
       if (cReturns && !node.alternate) {
         return makeBranch(cVal, falseEnv);
       }
       if (cReturns && node.alternate) {
         if (aReturns) {
-          return makeReturn(simplifyUnion4([cVal, aVal]));
+          return makeReturn(joinOrUnion(cVal, aVal));
         }
         return makeBranch(cVal, falseEnv);
       }
@@ -2498,8 +2883,8 @@ function evaluateNode(node, env) {
       }
       const allVals = [cVal];
       if (aVal !== null) allVals.push(aVal);
-      else allVals.push(T12.undefined);
-      return simplifyUnion4(allVals);
+      else allVals.push(T15.undefined);
+      return simplifyUnion8(allVals);
     }
     case "BlockStatement": {
       const blockEnv = env.fork();
@@ -2509,14 +2894,14 @@ function evaluateNode(node, env) {
     case "ReturnStatement": {
       if (_activeAsOverride) return makeReturn(_activeAsOverride);
       const arg = node.argument;
-      if (!arg) return makeReturn(T12.undefined);
+      if (!arg) return makeReturn(T15.undefined);
       const val = evaluate(arg, env);
       if (isReturn(val) || isBranch(val) || isThrow(val)) return val;
       return makeReturn(val);
     }
     case "VariableDeclaration": {
       for (const decl of node.declarations) {
-        const init = _activeAsOverride ?? (decl.init ? evaluate(decl.init, env) : T12.undefined);
+        const init = _activeAsOverride ?? (decl.init ? evaluate(decl.init, env) : T15.undefined);
         if (isReturn(init) || isBranch(init) || isThrow(init)) return init;
         if (init.kind === "function" && decl.id.type === "Identifier" && !init._name) {
           init._name = decl.id.name;
@@ -2526,7 +2911,7 @@ function evaluateNode(node, env) {
           recordNodeType(decl.id, init);
         }
       }
-      return T12.undefined;
+      return T15.undefined;
     }
     case "AssignmentExpression": {
       if (node.left.type === "Identifier") {
@@ -2537,7 +2922,7 @@ function evaluateNode(node, env) {
           const leftVal = env.lookup(node.left.name);
           if (leftVal && leftVal.kind !== "unknown") {
             const binaryOp = node.operator.slice(0, -1);
-            val = dispatchBinaryOp(binaryOp, leftVal, rightVal);
+            val = evalBinaryValue(binaryOp, leftVal, rightVal) ?? T15.unknown;
           }
         }
         if (!env.update(node.left.name, val)) {
@@ -2580,7 +2965,7 @@ function evaluateNode(node, env) {
         bindPattern(node.left, val, env);
         return val;
       }
-      return T12.unknown;
+      return T15.unknown;
     }
     case "ForOfStatement": {
       const rightVal = evaluate(node.right, env);
@@ -2602,22 +2987,22 @@ function evaluateNode(node, env) {
       return evaluateDoWhileStatement(node, env);
     }
     case "FunctionDeclaration": {
-      if (!node.id) return T12.undefined;
+      if (!node.id) return T15.undefined;
       const paramNames = node.params.map(describeParam);
-      const fnType = T12.fn(paramNames, node.body, env);
+      const fnType = T15.fn(paramNames, node.body, env);
       fnType._paramPatterns = node.params;
       if (node.id) fnType._name = node.id.name;
       if (node.async) fnType._async = true;
       fnType._hasArguments = true;
       tagFnModule(fnType);
       env.bind(node.id.name, fnType);
-      return T12.undefined;
+      return T15.undefined;
     }
     case "FunctionExpression":
     case "ArrowFunctionExpression": {
       const paramNames = node.params.map(describeParam);
       const body = node.body;
-      const fnType = T12.fn(paramNames, body, env);
+      const fnType = T15.fn(paramNames, body, env);
       fnType._paramPatterns = node.params;
       if (node.id) fnType._name = node.id.name;
       if (node.async) fnType._async = true;
@@ -2669,7 +3054,7 @@ function evaluateNode(node, env) {
           }
         }
       }
-      return T12.undefined;
+      return T15.undefined;
     }
     case "ExportDefaultDeclaration": {
       const decl = node.declaration;
@@ -2682,7 +3067,7 @@ function evaluateNode(node, env) {
       } else {
         env.bind(`__export_default`, result);
       }
-      return T12.undefined;
+      return T15.undefined;
     }
     case "CallExpression": {
       const callee = node.callee;
@@ -2719,7 +3104,7 @@ function evaluateNode(node, env) {
         return full.value;
       }
       return distributeOverUnion(calleeVal, (fn) => {
-        if (fn.kind !== "function") return T12.unknown;
+        if (fn.kind !== "function") return T15.unknown;
         return callFunction(fn, argVals, thisVal);
       });
     }
@@ -2729,7 +3114,7 @@ function evaluateNode(node, env) {
         const objVal = evaluate(callee.object, env);
         if (isReturn(objVal) || isBranch(objVal) || isThrow(objVal)) return objVal;
         if (objVal.kind === "literal" && (objVal.value === null || objVal.value === void 0)) {
-          return T12.undefined;
+          return T15.undefined;
         }
         const methodResult = evaluateMethodCall(callee, node.arguments, env);
         if (methodResult !== null) return methodResult;
@@ -2737,7 +3122,7 @@ function evaluateNode(node, env) {
       const calleeVal = evaluate(callee, env);
       if (isReturn(calleeVal) || isBranch(calleeVal) || isThrow(calleeVal)) return calleeVal;
       if (calleeVal.kind === "literal" && (calleeVal.value === null || calleeVal.value === void 0)) {
-        return T12.undefined;
+        return T15.undefined;
       }
       const argVals = evaluateArgs(node.arguments, env);
       if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
@@ -2759,7 +3144,7 @@ function evaluateNode(node, env) {
         return full.value;
       }
       return distributeOverUnion(calleeVal, (fn) => {
-        if (fn.kind !== "function") return T12.unknown;
+        if (fn.kind !== "function") return T15.unknown;
         return callFunction(fn, argVals, thisVal);
       });
     }
@@ -2781,10 +3166,10 @@ function evaluateNode(node, env) {
             if (bound !== void 0) return bound;
           }
           const builtinName = obj._builtinName;
-          if (builtinName && hasOwnProp(BUILTIN_STATIC_METHODS, builtinName)) {
+          if (builtinName && hasOwnProp3(BUILTIN_STATIC_METHODS, builtinName)) {
             const builtin = BUILTIN_STATIC_METHODS[builtinName];
-            if (typeof builtin === "object" && hasOwnProp(builtin, propName)) {
-              if (builtinName === "Symbol" && hasOwnProp(SYMBOL_STATIC_PROPS, propName)) {
+            if (typeof builtin === "object" && hasOwnProp3(builtin, propName)) {
+              if (builtinName === "Symbol" && hasOwnProp3(SYMBOL_STATIC_PROPS, propName)) {
                 return wellKnownSymbol(propName);
               }
               return builtin[propName];
@@ -2794,65 +3179,65 @@ function evaluateNode(node, env) {
             return builtinPrototype(builtinName);
           }
           if (obj.kind === "instance" && obj.className === "Map" && propName === "size") {
-            return T12.number;
+            return T15.number;
           }
           if (obj.kind === "instance" && obj.className === "Set" && propName === "size") {
-            return T12.number;
+            return T15.number;
           }
           if (obj.kind === "object") {
-            const ownVal = hasOwnProp(obj.properties, propName) ? obj.properties[propName] : void 0;
+            const ownVal = hasOwnProp3(obj.properties, propName) ? obj.properties[propName] : void 0;
             if (ownVal) return ownVal;
-            const protoFn = hasOwnProp(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
+            const protoFn = hasOwnProp3(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
             if (protoFn) return bindObjectProtoMethod(protoFn, obj);
-            return T12.undefined;
+            return T15.undefined;
           }
           if (obj.kind === "instance") {
-            const own = hasOwnProp(obj.properties, propName) ? obj.properties[propName] : void 0;
+            const own = hasOwnProp3(obj.properties, propName) ? obj.properties[propName] : void 0;
             if (own) return own;
-            const protoFn = hasOwnProp(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
+            const protoFn = hasOwnProp3(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
             if (protoFn) return bindObjectProtoMethod(protoFn, obj);
             if (propName === "constructor") return builtinClassValue(obj.className);
             const knownInstanceMethods = {
-              values: T12.fnSig([], T12.array(T12.unknown)),
-              keys: T12.fnSig([], T12.array(T12.unknown)),
-              entries: T12.fnSig([], T12.array(T12.tuple([T12.unknown, T12.unknown]))),
-              get: T12.fnSig([T12.unknown], T12.unknown),
-              has: T12.fnSig([T12.unknown], T12.boolean),
-              add: T12.fnSig([T12.unknown], T12.unknown),
-              set: T12.fnSig([T12.unknown, T12.unknown], T12.unknown),
-              delete: T12.fnSig([T12.unknown], T12.boolean),
-              forEach: T12.fnSig([T12.unknown], T12.undefined),
-              call: T12.fnSig([T12.unknown], T12.unknown),
-              apply: T12.fnSig([T12.unknown], T12.unknown),
-              bind: T12.fnSig([T12.unknown], T12.unknown)
+              values: T15.fnSig([], T15.array(T15.unknown)),
+              keys: T15.fnSig([], T15.array(T15.unknown)),
+              entries: T15.fnSig([], T15.array(T15.tuple([T15.unknown, T15.unknown]))),
+              get: T15.fnSig([T15.unknown], T15.unknown),
+              has: T15.fnSig([T15.unknown], T15.boolean),
+              add: T15.fnSig([T15.unknown], T15.unknown),
+              set: T15.fnSig([T15.unknown, T15.unknown], T15.unknown),
+              delete: T15.fnSig([T15.unknown], T15.boolean),
+              forEach: T15.fnSig([T15.unknown], T15.undefined),
+              call: T15.fnSig([T15.unknown], T15.unknown),
+              apply: T15.fnSig([T15.unknown], T15.unknown),
+              bind: T15.fnSig([T15.unknown], T15.unknown)
             };
-            const knownFn = hasOwnProp(knownInstanceMethods, propName) ? knownInstanceMethods[propName] : void 0;
+            const knownFn = hasOwnProp3(knownInstanceMethods, propName) ? knownInstanceMethods[propName] : void 0;
             if (knownFn) return knownFn;
-            return T12.fnSig([T12.unknown], T12.unknown);
+            return T15.fnSig([T15.unknown], T15.unknown);
           }
           if (propName === "length" && (obj.kind === "array" || obj.kind === "tuple")) {
-            return obj.kind === "tuple" ? T12.literal(obj.elements.length) : T12.number;
+            return obj.kind === "tuple" ? T15.literal(obj.elements.length) : T15.number;
           }
           if (obj.kind === "array" || obj.kind === "tuple") {
-            return T12.undefined;
+            return T15.undefined;
           }
           if (propName === "length" && obj.kind === "literal" && typeof obj.value === "string") {
-            return T12.literal(obj.value.length);
+            return T15.literal(obj.value.length);
           }
           if (propName === "length" && obj.kind === "primitive" && obj.type === "string") {
-            return T12.number;
+            return T15.number;
           }
           if (obj.kind === "promise") {
-            const protoFn = hasOwnProp(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
+            const protoFn = hasOwnProp3(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
             if (protoFn) return bindObjectProtoMethod(protoFn, obj);
             const promiseMethods = BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Promise;
-            if (promiseMethods && hasOwnProp(promiseMethods, propName)) {
+            if (promiseMethods && hasOwnProp3(promiseMethods, propName)) {
               return promiseMethods[propName];
             }
           }
           if (obj.kind === "primitive" || obj.kind === "literal" && (typeof obj.value === "string" || typeof obj.value === "number" || typeof obj.value === "boolean")) {
             const wrapper2 = wrapperPrototypeMember(obj, propName);
-            return wrapper2 !== void 0 ? wrapper2 : T12.undefined;
+            return wrapper2 !== void 0 ? wrapper2 : T15.undefined;
           }
           const wrapper = wrapperPrototypeMember(obj, propName);
           if (wrapper !== void 0) return wrapper;
@@ -2861,7 +3246,7 @@ function evaluateNode(node, env) {
             if (result2 !== void 0) return result2;
           }
           propMissed = true;
-          return T12.unknown;
+          return T15.unknown;
         });
         if (propMissed) {
           recordUnknown({
@@ -2874,13 +3259,13 @@ function evaluateNode(node, env) {
         }
         return result;
       }
-      return T12.unknown;
+      return T15.unknown;
     }
     case "OptionalMemberExpression": {
       const objVal = evaluate(node.object, env);
       if (isReturn(objVal) || isBranch(objVal) || isThrow(objVal)) return objVal;
       if (objVal.kind === "literal" && (objVal.value === null || objVal.value === void 0)) {
-        return T12.undefined;
+        return T15.undefined;
       }
       node._receiverVal = objVal;
       if (node.computed) {
@@ -2901,59 +3286,59 @@ function evaluateNode(node, env) {
             return builtinPrototype(optBuiltinName);
           }
           if (obj.kind === "object") {
-            const ownVal = hasOwnProp(obj.properties, propName) ? obj.properties[propName] : void 0;
+            const ownVal = hasOwnProp3(obj.properties, propName) ? obj.properties[propName] : void 0;
             if (ownVal) return ownVal;
-            const protoFn = hasOwnProp(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
+            const protoFn = hasOwnProp3(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
             if (protoFn) return bindObjectProtoMethod(protoFn, obj);
-            return T12.undefined;
+            return T15.undefined;
           }
           if (obj.kind === "instance") {
-            const own = hasOwnProp(obj.properties, propName) ? obj.properties[propName] : void 0;
+            const own = hasOwnProp3(obj.properties, propName) ? obj.properties[propName] : void 0;
             if (own) return own;
-            const protoFn = hasOwnProp(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
+            const protoFn = hasOwnProp3(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
             if (protoFn) return bindObjectProtoMethod(protoFn, obj);
             if (propName === "constructor") return builtinClassValue(obj.className);
             const knownInstanceMethods = {
-              values: T12.fnSig([], T12.array(T12.unknown)),
-              keys: T12.fnSig([], T12.array(T12.unknown)),
-              entries: T12.fnSig([], T12.array(T12.tuple([T12.unknown, T12.unknown]))),
-              get: T12.fnSig([T12.unknown], T12.unknown),
-              has: T12.fnSig([T12.unknown], T12.boolean),
-              add: T12.fnSig([T12.unknown], T12.unknown),
-              set: T12.fnSig([T12.unknown, T12.unknown], T12.unknown),
-              delete: T12.fnSig([T12.unknown], T12.boolean),
-              forEach: T12.fnSig([T12.unknown], T12.undefined),
-              call: T12.fnSig([T12.unknown], T12.unknown),
-              apply: T12.fnSig([T12.unknown], T12.unknown),
-              bind: T12.fnSig([T12.unknown], T12.unknown)
+              values: T15.fnSig([], T15.array(T15.unknown)),
+              keys: T15.fnSig([], T15.array(T15.unknown)),
+              entries: T15.fnSig([], T15.array(T15.tuple([T15.unknown, T15.unknown]))),
+              get: T15.fnSig([T15.unknown], T15.unknown),
+              has: T15.fnSig([T15.unknown], T15.boolean),
+              add: T15.fnSig([T15.unknown], T15.unknown),
+              set: T15.fnSig([T15.unknown, T15.unknown], T15.unknown),
+              delete: T15.fnSig([T15.unknown], T15.boolean),
+              forEach: T15.fnSig([T15.unknown], T15.undefined),
+              call: T15.fnSig([T15.unknown], T15.unknown),
+              apply: T15.fnSig([T15.unknown], T15.unknown),
+              bind: T15.fnSig([T15.unknown], T15.unknown)
             };
-            const knownFn = hasOwnProp(knownInstanceMethods, propName) ? knownInstanceMethods[propName] : void 0;
+            const knownFn = hasOwnProp3(knownInstanceMethods, propName) ? knownInstanceMethods[propName] : void 0;
             if (knownFn) return knownFn;
-            return T12.fnSig([T12.unknown], T12.unknown);
+            return T15.fnSig([T15.unknown], T15.unknown);
           }
           if (propName === "length" && (obj.kind === "array" || obj.kind === "tuple")) {
-            return obj.kind === "tuple" ? T12.literal(obj.elements.length) : T12.number;
+            return obj.kind === "tuple" ? T15.literal(obj.elements.length) : T15.number;
           }
           if (obj.kind === "array" || obj.kind === "tuple") {
-            return T12.undefined;
+            return T15.undefined;
           }
           if (propName === "length" && obj.kind === "literal" && typeof obj.value === "string") {
-            return T12.literal(obj.value.length);
+            return T15.literal(obj.value.length);
           }
           if (propName === "length" && obj.kind === "primitive" && obj.type === "string") {
-            return T12.number;
+            return T15.number;
           }
           if (obj.kind === "promise") {
-            const protoFn = hasOwnProp(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
+            const protoFn = hasOwnProp3(OBJECT_PROTOTYPE_METHODS, propName) ? OBJECT_PROTOTYPE_METHODS[propName] : void 0;
             if (protoFn) return bindObjectProtoMethod(protoFn, obj);
             const promiseMethods = BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Promise;
-            if (promiseMethods && hasOwnProp(promiseMethods, propName)) {
+            if (promiseMethods && hasOwnProp3(promiseMethods, propName)) {
               return promiseMethods[propName];
             }
           }
           if (obj.kind === "primitive" || obj.kind === "literal" && (typeof obj.value === "string" || typeof obj.value === "number" || typeof obj.value === "boolean")) {
             const wrapper2 = wrapperPrototypeMember(obj, propName);
-            return wrapper2 !== void 0 ? wrapper2 : T12.undefined;
+            return wrapper2 !== void 0 ? wrapper2 : T15.undefined;
           }
           const wrapper = wrapperPrototypeMember(obj, propName);
           if (wrapper !== void 0) return wrapper;
@@ -2962,7 +3347,7 @@ function evaluateNode(node, env) {
             if (result2 !== void 0) return result2;
           }
           propMissed = true;
-          return T12.unknown;
+          return T15.unknown;
         });
         if (propMissed) {
           recordUnknown({
@@ -2975,7 +3360,7 @@ function evaluateNode(node, env) {
         }
         return result;
       }
-      return T12.unknown;
+      return T15.unknown;
     }
     case "ObjectExpression": {
       const props = {};
@@ -2998,11 +3383,18 @@ function evaluateNode(node, env) {
               if (p.type === "RestElement" && p.argument.type === "Identifier") return `...${p.argument.name}`;
               return `__param`;
             });
-            props[key] = T12.fn(params, prop.body, env);
+            props[key] = T15.fn(params, prop.body, env);
           }
         } else if (prop.type === "SpreadElement") {
           const spreadVal = evaluate(prop.argument, env);
           if (isReturn(spreadVal) || isBranch(spreadVal) || isThrow(spreadVal)) return spreadVal;
+          const absSpread = tryAbsObjectSpread(T15.object(props), spreadVal);
+          if (absSpread !== void 0 && absSpread.kind === "object") {
+            for (const [k, v] of Object.entries(absSpread.properties)) {
+              props[k] = v;
+            }
+            continue;
+          }
           if (spreadVal.kind === "object") {
             Object.assign(props, spreadVal.properties);
           } else if (spreadVal.kind === "union") {
@@ -3017,20 +3409,20 @@ function evaluateNode(node, env) {
               for (const key of allKeys) {
                 const values = objectMembers.filter((m) => m.kind === "object" && key in m.properties).map((m) => m.properties[key]);
                 if (values.length > 0) {
-                  props[key] = simplifyUnion4(values);
+                  props[key] = simplifyUnion8(values);
                 }
               }
             }
           }
         }
       }
-      return T12.object(props);
+      return T15.object(props);
     }
     case "ArrayExpression": {
       const elements = [];
       for (const elem of node.elements) {
         if (!elem) {
-          elements.push(T12.undefined);
+          elements.push(T15.undefined);
           continue;
         }
         if (elem.type === "SpreadElement") {
@@ -3039,19 +3431,19 @@ function evaluateNode(node, env) {
           if (spreadVal.kind === "tuple") {
             elements.push(...spreadVal.elements);
           } else if (spreadVal.kind === "array") {
-            return T12.array(simplifyUnion4([...elements, spreadVal.element]));
+            return T15.array(simplifyUnion8([...elements, spreadVal.element]));
           } else {
             const iterable = iterableSpreadValue(spreadVal);
             if (iterable) {
               if (iterable.kind === "tuple") {
                 elements.push(...iterable.elements);
               } else if (iterable.kind === "array") {
-                return T12.array(simplifyUnion4([...elements, iterable.element]));
+                return T15.array(simplifyUnion8([...elements, iterable.element]));
               } else {
-                elements.push(T12.unknown);
+                elements.push(T15.unknown);
               }
             } else {
-              elements.push(T12.unknown);
+              elements.push(T15.unknown);
             }
           }
           continue;
@@ -3060,10 +3452,10 @@ function evaluateNode(node, env) {
         if (isReturn(val) || isBranch(val) || isThrow(val)) return val;
         elements.push(val);
       }
-      return T12.tuple(elements);
+      return T15.tuple(elements);
     }
     case "ThrowStatement": {
-      const argVal = node.argument ? evaluate(node.argument, env) : T12.undefined;
+      const argVal = node.argument ? evaluate(node.argument, env) : T15.undefined;
       if (isReturn(argVal) || isBranch(argVal) || isThrow(argVal)) return argVal;
       const throwLoc = node.loc ? {
         start: { line: node.loc.start.line, column: node.loc.start.column },
@@ -3088,21 +3480,21 @@ function evaluateNode(node, env) {
       if (node.argument.type === "Identifier") {
         const current = env.lookup(node.argument.name);
         if (current.kind === "literal" && typeof current.value === "number") {
-          const newVal = node.operator === "++" ? T12.literal(current.value + 1) : T12.literal(current.value - 1);
+          const newVal = node.operator === "++" ? T15.literal(current.value + 1) : T15.literal(current.value - 1);
           if (!env.update(node.argument.name, newVal)) {
             env.bind(node.argument.name, newVal);
           }
           return node.prefix ? newVal : current;
         }
-        if (!env.update(node.argument.name, T12.number)) {
-          env.bind(node.argument.name, T12.number);
+        if (!env.update(node.argument.name, T15.number)) {
+          env.bind(node.argument.name, T15.number);
         }
-        return T12.number;
+        return T15.number;
       }
-      return T12.number;
+      return T15.number;
     }
     default:
-      return T12.unknown;
+      return T15.unknown;
   }
 }
 function getMemberKey(node, env) {
@@ -3130,7 +3522,7 @@ function bindPattern(pattern, value, env) {
   }
   if (pattern.type === "AssignmentPattern") {
     const defaultVal = evaluate(pattern.right, env);
-    const resolved = value.kind === "literal" && value.value === void 0 ? !isReturn(defaultVal) && !isBranch(defaultVal) && !isThrow(defaultVal) ? defaultVal : T12.unknown : value;
+    const resolved = value.kind === "literal" && value.value === void 0 ? !isReturn(defaultVal) && !isBranch(defaultVal) && !isThrow(defaultVal) ? defaultVal : T15.unknown : value;
     bindPattern(pattern.left, resolved, env);
     return;
   }
@@ -3143,9 +3535,9 @@ function bindPattern(pattern, value, env) {
           for (const [k, v] of Object.entries(value.properties)) {
             if (!restKeys.includes(k)) remaining[k] = v;
           }
-          bindPattern(prop.argument, T12.object(remaining), env);
+          bindPattern(prop.argument, T15.object(remaining), env);
         } else {
-          bindPattern(prop.argument, T12.object({}), env);
+          bindPattern(prop.argument, T15.object({}), env);
         }
         continue;
       }
@@ -3153,7 +3545,7 @@ function bindPattern(pattern, value, env) {
       const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
       if (!key) continue;
       restKeys.push(key);
-      const propVal = value.kind === "object" ? hasOwnProp(value.properties, key) ? value.properties[key] : hasOwnProp(OBJECT_PROTOTYPE_METHODS, key) ? bindObjectProtoMethod(OBJECT_PROTOTYPE_METHODS[key], value) : T12.undefined : T12.unknown;
+      const propVal = value.kind === "object" ? hasOwnProp3(value.properties, key) ? value.properties[key] : hasOwnProp3(OBJECT_PROTOTYPE_METHODS, key) ? bindObjectProtoMethod(OBJECT_PROTOTYPE_METHODS[key], value) : T15.undefined : T15.unknown;
       bindPattern(prop.value, propVal, env);
     }
     return;
@@ -3164,15 +3556,15 @@ function bindPattern(pattern, value, env) {
       if (!elem) continue;
       if (elem.type === "RestElement") {
         if (value.kind === "tuple") {
-          bindPattern(elem.argument, T12.tuple(value.elements.slice(i)), env);
+          bindPattern(elem.argument, T15.tuple(value.elements.slice(i)), env);
         } else if (value.kind === "array") {
           bindPattern(elem.argument, value, env);
         } else {
-          bindPattern(elem.argument, T12.tuple([]), env);
+          bindPattern(elem.argument, T15.tuple([]), env);
         }
         continue;
       }
-      const elemVal = value.kind === "tuple" ? value.elements[i] ?? T12.undefined : value.kind === "array" ? value.element : T12.unknown;
+      const elemVal = value.kind === "tuple" ? value.elements[i] ?? T15.undefined : value.kind === "array" ? value.element : T15.unknown;
       bindPattern(elem, elemVal, env);
     }
     return;
@@ -3196,10 +3588,10 @@ function evaluateArgs(args, env) {
           } else if (iterable.kind === "array") {
             result.push(iterable.element);
           } else {
-            result.push(T12.unknown);
+            result.push(T15.unknown);
           }
         } else {
-          result.push(T12.unknown);
+          result.push(T15.unknown);
         }
       }
       continue;
@@ -3218,53 +3610,53 @@ function evaluateBuiltinCall(name, args, env) {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
     if (argVals.length === 0) {
-      if (name === "String") return T12.literal("");
-      if (name === "Number") return T12.literal(0);
-      if (name === "Boolean") return T12.literal(false);
+      if (name === "String") return T15.literal("");
+      if (name === "Number") return T15.literal(0);
+      if (name === "Boolean") return T15.literal(false);
     }
     if (argVals.length === 1) {
       const arg = argVals[0];
       if (name === "String") {
-        if (arg.kind === "literal") return T12.literal(String(arg.value));
-        return T12.string;
+        if (arg.kind === "literal") return T15.literal(String(arg.value));
+        return T15.string;
       }
       if (name === "Number") {
         if (arg.kind === "literal") {
-          if (arg.value === null) return T12.literal(0);
-          if (arg.value === void 0) return T12.literal(NaN);
-          if (typeof arg.value === "boolean") return T12.literal(arg.value ? 1 : 0);
+          if (arg.value === null) return T15.literal(0);
+          if (arg.value === void 0) return T15.literal(NaN);
+          if (typeof arg.value === "boolean") return T15.literal(arg.value ? 1 : 0);
           if (typeof arg.value === "number") return arg;
           if (typeof arg.value === "string") {
             const num = Number(arg.value);
-            if (!isNaN(num)) return T12.literal(num);
-            return T12.literal(NaN);
+            if (!isNaN(num)) return T15.literal(num);
+            return T15.literal(NaN);
           }
         }
-        return T12.number;
+        return T15.number;
       }
       if (name === "Boolean") {
-        if (arg.kind === "literal") return T12.literal(Boolean(arg.value));
-        return T12.boolean;
+        if (arg.kind === "literal") return T15.literal(Boolean(arg.value));
+        return T15.boolean;
       }
     }
-    if (name === "String") return T12.string;
-    if (name === "Number") return T12.number;
-    if (name === "Boolean") return T12.boolean;
+    if (name === "String") return T15.string;
+    if (name === "Number") return T15.number;
+    if (name === "Boolean") return T15.boolean;
   }
   if (name === "parseInt" || name === "parseFloat") {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-    return T12.number;
+    return T15.number;
   }
   if (name === "isNaN" || name === "isFinite") {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-    return T12.boolean;
+    return T15.boolean;
   }
   if (name === "encodeURIComponent" || name === "decodeURIComponent" || name === "encodeURI" || name === "decodeURI") {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-    return T12.string;
+    return T15.string;
   }
   if (name === "Math") {
     return null;
@@ -3273,7 +3665,7 @@ function evaluateBuiltinCall(name, args, env) {
     return null;
   }
   if (name === "fetch") {
-    return T12.promise(createResponseType());
+    return T15.promise(createResponseType());
   }
   return null;
 }
@@ -3292,7 +3684,7 @@ function evaluateFunctionPrototypeMethod(fnVal, methodName, argVals) {
     if (listArg?.kind === "tuple") {
       spreadArgs = listArg.elements;
     } else {
-      const el = listArg?.kind === "array" ? listArg.element : T12.unknown;
+      const el = listArg?.kind === "array" ? listArg.element : T15.unknown;
       spreadArgs = fnVal.params.map(() => el);
     }
     const full = callFunctionFull(fnVal, spreadArgs, argVals[0]);
@@ -3351,11 +3743,11 @@ function evaluateMethodCall(callee, args, env) {
         methodMissed = true;
       }
       if (memberResult !== null && typeof memberResult === "object") {
-        if (THROW_SIGNAL in memberResult) return T12.never;
+        if (THROW_SIGNAL in memberResult) return T15.never;
         if (RETURN_SIGNAL in memberResult) return memberResult.value;
         if (BRANCH_SIGNAL in memberResult) return memberResult.returnedValue;
       }
-      return memberResult ?? T12.unknown;
+      return memberResult ?? T15.unknown;
     });
     if (methodMissed) {
       recordUnknown({
@@ -3377,7 +3769,7 @@ function evaluateMethodCall(callee, args, env) {
   if (callee.object.type === "Identifier" && callee.object.name === "console" && !env.has("console")) {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-    return T12.undefined;
+    return T15.undefined;
   }
   if (callee.object.type === "Identifier" && callee.object.name === "Math" && !env.has("Math")) {
     const argVals = evaluateArgs(args, env);
@@ -3404,27 +3796,27 @@ function evaluateMethodCall(callee, args, env) {
       "atan",
       "atan2"
     ].includes(methodName)) {
-      return T12.number;
+      return T15.number;
     }
     if (["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT1_2", "SQRT2"].includes(methodName)) {
-      return T12.number;
+      return T15.number;
     }
-    return T12.number;
+    return T15.number;
   }
   if (callee.object.type === "Identifier" && callee.object.name === "Date" && !env.has("Date")) {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
     if (["now", "parse", "UTC"].includes(methodName)) {
-      return T12.number;
+      return T15.number;
     }
     if (methodName === "constructor") {
-      return T12.instanceOf("Date", {
-        getTime: T12.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-        getFullYear: T12.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
-        toISOString: T12.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
+      return T15.instanceOf("Date", {
+        getTime: T15.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+        getFullYear: T15.fn(["...args"], { type: "BlockStatement", body: [] }, void 0),
+        toISOString: T15.fn(["...args"], { type: "BlockStatement", body: [] }, void 0)
       });
     }
-    return T12.unknown;
+    return T15.unknown;
   }
   if (callee.object.type === "Identifier" && callee.object.name === "JSON" && !env.has("JSON")) {
     const argVals = evaluateArgs(args, env);
@@ -3436,9 +3828,9 @@ function evaluateMethodCall(callee, args, env) {
       );
     }
     if (methodName === "stringify") {
-      return T12.string;
+      return T15.string;
     }
-    return T12.unknown;
+    return T15.unknown;
   }
   if (callee.object.type === "Identifier" && callee.object.name === "Array" && !env.has("Array")) {
     const argVals = evaluateArgs(args, env);
@@ -3448,7 +3840,7 @@ function evaluateMethodCall(callee, args, env) {
         const iterable = argVals[0];
         if (iterable.kind === "instance" && iterable.className === "Set") {
           const typeArgs = iterable._typeArgs;
-          if (typeArgs?.T) return T12.array(typeArgs.T);
+          if (typeArgs?.T) return T15.array(typeArgs.T);
         }
         if (iterable.kind === "tuple") {
           return iterable;
@@ -3457,36 +3849,36 @@ function evaluateMethodCall(callee, args, env) {
           return iterable;
         }
       }
-      return T12.array(T12.unknown);
+      return T15.array(T15.unknown);
     }
     if (methodName === "isArray") {
-      return distributeOverUnion(argVals[0] ?? T12.undefined, (v) => {
-        const lit = arrayIsArrayLiteral(v);
-        return lit === void 0 ? T12.boolean : T12.literal(lit);
+      return distributeOverUnion(argVals[0] ?? T15.undefined, (v) => {
+        const lit3 = arrayIsArrayLiteral(v);
+        return lit3 === void 0 ? T15.boolean : T15.literal(lit3);
       });
     }
-    return T12.unknown;
+    return T15.unknown;
   }
   if (callee.object.type === "Identifier" && callee.object.name === "Promise" && !env.has("Promise")) {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
     const result = evaluatePromiseStaticMethod(methodName, argVals);
     if (result !== null) return result;
-    return T12.unknown;
+    return T15.unknown;
   }
   if (callee.object.type === "Identifier" && callee.object.name === "Symbol" && !env.has("Symbol")) {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-    if (methodName === "for") return T12.symbol;
-    if (methodName === "keyFor") return T12.union(T12.string, T12.undefined);
-    return T12.unknown;
+    if (methodName === "for") return T15.symbol;
+    if (methodName === "keyFor") return T15.union(T15.string, T15.undefined);
+    return T15.unknown;
   }
   if (callee.object.type === "Identifier" && callee.object.name === "Reflect" && !env.has("Reflect")) {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
     const method = REFLECT_METHODS[methodName];
     if (method) return method(...argVals);
-    return T12.unknown;
+    return T15.unknown;
   }
   if (objVal.kind === "promise") {
     const argVals = evaluateArgs(args, env);
@@ -3643,12 +4035,12 @@ function evaluateMethodCall(callee, args, env) {
     const argVals = evaluateArgs(args, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
     if (methodName === "toString") {
-      return objVal.kind === "literal" && typeof objVal.value === "number" ? T12.literal(String(objVal.value)) : T12.string;
+      return objVal.kind === "literal" && typeof objVal.value === "number" ? T15.literal(String(objVal.value)) : T15.string;
     }
     if (methodName === "valueOf") {
-      return objVal.kind === "literal" && typeof objVal.value === "number" ? objVal : T12.number;
+      return objVal.kind === "literal" && typeof objVal.value === "number" ? objVal : T15.number;
     }
-    if (methodName === "toFixed" || methodName === "toPrecision") return T12.string;
+    if (methodName === "toFixed" || methodName === "toPrecision") return T15.string;
   }
   if (objVal.kind === "refined") {
     const argVals = evaluateArgs(args, env);
@@ -3695,112 +4087,112 @@ function evaluateStringMethodLiteral(str, method, args) {
     // String.prototype.toString/valueOf return the receiver string itself
     case "toString":
     case "valueOf":
-      return T12.literal(str);
+      return T15.literal(str);
     case "toUpperCase":
-      return T12.literal(str.toUpperCase());
+      return T15.literal(str.toUpperCase());
     case "toLowerCase":
-      return T12.literal(str.toLowerCase());
+      return T15.literal(str.toLowerCase());
     case "trim":
-      return T12.literal(str.trim());
+      return T15.literal(str.trim());
     case "trimStart":
-      return T12.literal(str.trimStart());
+      return T15.literal(str.trimStart());
     case "trimEnd":
-      return T12.literal(str.trimEnd());
+      return T15.literal(str.trimEnd());
     case "charAt": {
       const idx = litArg(0);
-      return typeof idx === "number" ? T12.literal(str.charAt(idx)) : T12.string;
+      return typeof idx === "number" ? T15.literal(str.charAt(idx)) : T15.string;
     }
     case "charCodeAt": {
       const idx = litArg(0);
-      return typeof idx === "number" ? T12.literal(str.charCodeAt(idx)) : T12.number;
+      return typeof idx === "number" ? T15.literal(str.charCodeAt(idx)) : T15.number;
     }
     case "at": {
       const idx = litArg(0);
       if (typeof idx === "number") {
         const ch = str.at(idx);
-        return ch !== void 0 ? T12.literal(ch) : T12.undefined;
+        return ch !== void 0 ? T15.literal(ch) : T15.undefined;
       }
-      return T12.union(T12.string, T12.undefined);
+      return T15.union(T15.string, T15.undefined);
     }
     case "startsWith": {
       const search = litArg(0);
-      return typeof search === "string" ? T12.literal(str.startsWith(search)) : T12.boolean;
+      return typeof search === "string" ? T15.literal(str.startsWith(search)) : T15.boolean;
     }
     case "endsWith": {
       const search = litArg(0);
-      return typeof search === "string" ? T12.literal(str.endsWith(search)) : T12.boolean;
+      return typeof search === "string" ? T15.literal(str.endsWith(search)) : T15.boolean;
     }
     case "includes": {
       const search = litArg(0);
-      return typeof search === "string" ? T12.literal(str.includes(search)) : T12.boolean;
+      return typeof search === "string" ? T15.literal(str.includes(search)) : T15.boolean;
     }
     case "indexOf": {
       const search = litArg(0);
-      return typeof search === "string" ? T12.literal(str.indexOf(search)) : T12.number;
+      return typeof search === "string" ? T15.literal(str.indexOf(search)) : T15.number;
     }
     case "lastIndexOf": {
       const search = litArg(0);
-      return typeof search === "string" ? T12.literal(str.lastIndexOf(search)) : T12.number;
+      return typeof search === "string" ? T15.literal(str.lastIndexOf(search)) : T15.number;
     }
     case "slice": {
       const start = litArg(0);
       const end = litArg(1);
       if (typeof start === "number") {
-        return T12.literal(str.slice(start, typeof end === "number" ? end : void 0));
+        return T15.literal(str.slice(start, typeof end === "number" ? end : void 0));
       }
-      return T12.string;
+      return T15.string;
     }
     case "substring": {
       const start = litArg(0);
       const end = litArg(1);
       if (typeof start === "number") {
-        return T12.literal(str.substring(start, typeof end === "number" ? end : void 0));
+        return T15.literal(str.substring(start, typeof end === "number" ? end : void 0));
       }
-      return T12.string;
+      return T15.string;
     }
     case "split": {
       const sep = litArg(0);
       if (typeof sep === "string") {
         const parts = str.split(sep);
-        return T12.tuple(parts.map((p) => T12.literal(p)));
+        return T15.tuple(parts.map((p) => T15.literal(p)));
       }
-      return T12.array(T12.string);
+      return T15.array(T15.string);
     }
     case "replace": {
       const search = litArg(0);
       const replacement = litArg(1);
       if (typeof search === "string" && typeof replacement === "string") {
-        return T12.literal(str.replace(search, replacement));
+        return T15.literal(str.replace(search, replacement));
       }
-      return T12.string;
+      return T15.string;
     }
     case "replaceAll": {
       const search = litArg(0);
       const replacement = litArg(1);
       if (typeof search === "string" && typeof replacement === "string") {
-        return T12.literal(str.replaceAll(search, replacement));
+        return T15.literal(str.replaceAll(search, replacement));
       }
-      return T12.string;
+      return T15.string;
     }
     case "repeat": {
       const count = litArg(0);
-      return typeof count === "number" ? T12.literal(str.repeat(count)) : T12.string;
+      return typeof count === "number" ? T15.literal(str.repeat(count)) : T15.string;
     }
     case "padStart": {
       const len = litArg(0);
       const fill = litArg(1);
       if (typeof len === "number") {
-        return T12.literal(str.padStart(len, typeof fill === "string" ? fill : void 0));
+        return T15.literal(str.padStart(len, typeof fill === "string" ? fill : void 0));
       }
-      return T12.string;
+      return T15.string;
     }
     case "padEnd": {
       const len = litArg(0);
       const fill = litArg(1);
       if (typeof len === "number") {
-        return T12.literal(str.padEnd(len, typeof fill === "string" ? fill : void 0));
+        return T15.literal(str.padEnd(len, typeof fill === "string" ? fill : void 0));
       }
-      return T12.string;
+      return T15.string;
     }
     default:
       return null;
@@ -3810,7 +4202,7 @@ function evaluateStringMethodAbstract(method, _args) {
   switch (method) {
     case "toString":
     case "valueOf":
-      return T12.string;
+      return T15.string;
     case "toUpperCase":
     case "toLowerCase":
     case "trim":
@@ -3824,19 +4216,19 @@ function evaluateStringMethodAbstract(method, _args) {
     case "repeat":
     case "padStart":
     case "padEnd":
-      return T12.string;
+      return T15.string;
     case "charCodeAt":
     case "indexOf":
     case "lastIndexOf":
-      return T12.number;
+      return T15.number;
     case "at":
-      return T12.union(T12.string, T12.undefined);
+      return T15.union(T15.string, T15.undefined);
     case "startsWith":
     case "endsWith":
     case "includes":
-      return T12.boolean;
+      return T15.boolean;
     case "split":
-      return T12.array(T12.string);
+      return T15.array(T15.string);
     default:
       return null;
   }
@@ -3844,12 +4236,12 @@ function evaluateStringMethodAbstract(method, _args) {
 function evaluateObjectStaticMethod(method, obj) {
   if (obj.kind === "instance") {
     if (method === "keys" || method === "getOwnPropertyNames") {
-      return T12.tuple(Object.keys(obj.properties).map((k) => T12.literal(k)));
+      return T15.tuple(Object.keys(obj.properties).map((k) => T15.literal(k)));
     }
-    if (method === "values") return T12.tuple(Object.values(obj.properties));
+    if (method === "values") return T15.tuple(Object.values(obj.properties));
     if (method === "entries") {
-      return T12.tuple(
-        Object.keys(obj.properties).map((k) => T12.tuple([T12.literal(k), obj.properties[k]]))
+      return T15.tuple(
+        Object.keys(obj.properties).map((k) => T15.tuple([T15.literal(k), obj.properties[k]]))
       );
     }
     return null;
@@ -3860,52 +4252,52 @@ function evaluateObjectStaticMethod(method, obj) {
       const literals = [];
       for (const r of per) {
         if (r?.kind === "tuple") literals.push(...r.elements);
-        else return T12.array(T12.string);
+        else return T15.array(T15.string);
       }
-      if (literals.length > 64) return T12.array(T12.string);
-      return T12.tuple(literals);
+      if (literals.length > 64) return T15.array(T15.string);
+      return T15.tuple(literals);
     }
     if (method === "values") {
       const vals = per.filter((r) => r && r.kind !== "unknown").flatMap((r) => r.kind === "tuple" ? r.elements : [r]);
-      if (per.some((r) => !r || r.kind === "unknown") || vals.length > 64) return T12.array(T12.unknown);
-      return T12.tuple(vals);
+      if (per.some((r) => !r || r.kind === "unknown") || vals.length > 64) return T15.array(T15.unknown);
+      return T15.tuple(vals);
     }
     if (method === "entries") {
-      return T12.array(T12.tuple([T12.string, T12.unknown]));
+      return T15.array(T15.tuple([T15.string, T15.unknown]));
     }
     return null;
   }
   if (obj.kind === "tuple") {
     if (method === "keys" || method === "getOwnPropertyNames") {
-      return T12.tuple(obj.elements.map((_, i) => T12.literal(String(i))));
+      return T15.tuple(obj.elements.map((_, i) => T15.literal(String(i))));
     }
-    if (method === "values") return T12.tuple([...obj.elements]);
+    if (method === "values") return T15.tuple([...obj.elements]);
     if (method === "entries") {
-      return T12.tuple(obj.elements.map((el, i) => T12.tuple([T12.literal(String(i)), el])));
+      return T15.tuple(obj.elements.map((el, i) => T15.tuple([T15.literal(String(i)), el])));
     }
     return null;
   }
   if (obj.kind !== "object") {
-    if (method === "keys") return T12.array(T12.string);
-    if (method === "values") return T12.array(T12.unknown);
-    if (method === "entries") return T12.array(T12.tuple([T12.string, T12.unknown]));
+    if (method === "keys") return T15.array(T15.string);
+    if (method === "values") return T15.array(T15.unknown);
+    if (method === "entries") return T15.array(T15.tuple([T15.string, T15.unknown]));
     return null;
   }
   const keys = Object.keys(obj.properties);
   const values = Object.values(obj.properties);
   if (method === "keys") {
-    return T12.tuple(keys.map((k) => T12.literal(k)));
+    return T15.tuple(keys.map((k) => T15.literal(k)));
   }
   if (method === "values") {
-    return T12.tuple(values);
+    return T15.tuple(values);
   }
   if (method === "entries") {
-    return T12.tuple(
-      keys.map((k) => T12.tuple([T12.literal(k), obj.properties[k]]))
+    return T15.tuple(
+      keys.map((k) => T15.tuple([T15.literal(k), obj.properties[k]]))
     );
   }
   if (method === "getOwnPropertyNames") {
-    return T12.tuple(keys.map((k) => T12.literal(k)));
+    return T15.tuple(keys.map((k) => T15.literal(k)));
   }
   return null;
 }
@@ -3919,51 +4311,51 @@ function evaluateArrayMethodValues(arr, method, argVals) {
   if (method === "push") {
     if (arr.kind === "tuple") {
       arr.elements.push(...argVals);
-      return T12.literal(arr.elements.length);
+      return T15.literal(arr.elements.length);
     }
-    return T12.number;
+    return T15.number;
   }
   if (method === "length") {
-    return arr.kind === "tuple" ? T12.literal(arr.elements.length) : T12.number;
+    return arr.kind === "tuple" ? T15.literal(arr.elements.length) : T15.number;
   }
   if (method === "pop" || method === "shift") {
     if (arr.kind === "tuple") {
-      if (arr.elements.length === 0) return T12.undefined;
-      return T12.union(...arr.elements);
+      if (arr.elements.length === 0) return T15.undefined;
+      return T15.union(...arr.elements);
     }
-    return T12.unknown;
+    return T15.unknown;
   }
   if (method === "unshift") {
     if (arr.kind === "tuple") {
-      return T12.literal(arr.elements.length + argVals.length);
+      return T15.literal(arr.elements.length + argVals.length);
     }
-    return T12.number;
+    return T15.number;
   }
   if (method === "indexOf" || method === "lastIndexOf") {
-    return T12.number;
+    return T15.number;
   }
   if (method === "includes") {
     if (arr.kind === "tuple" && argVals[0]?.kind === "literal") {
       const searchVal = argVals[0];
       const found = arr.elements.some((e) => typeValueEquals4(e, searchVal));
-      return T12.literal(found);
+      return T15.literal(found);
     }
-    return T12.boolean;
+    return T15.boolean;
   }
   if (method === "join") {
-    return T12.string;
+    return T15.string;
   }
   if (method === "concat") {
     if (arr.kind === "tuple") {
       const otherElements = [];
       for (const a of argVals) {
         if (a.kind === "tuple") otherElements.push(...a.elements);
-        else if (a.kind === "array") return T12.array(simplifyUnion4([...arr.elements, a.element]));
+        else if (a.kind === "array") return T15.array(simplifyUnion8([...arr.elements, a.element]));
         else otherElements.push(a);
       }
-      return T12.tuple([...arr.elements, ...otherElements]);
+      return T15.tuple([...arr.elements, ...otherElements]);
     }
-    return T12.array(arr.element);
+    return T15.array(arr.element);
   }
   if (method === "slice") {
     if (arr.kind === "tuple") {
@@ -3971,103 +4363,130 @@ function evaluateArrayMethodValues(arr, method, argVals) {
       const end = argVals[1];
       const startIdx = start?.kind === "literal" && typeof start.value === "number" ? start.value : 0;
       const endIdx = end?.kind === "literal" && typeof end.value === "number" ? end.value : arr.elements.length;
-      return T12.tuple(arr.elements.slice(startIdx, endIdx));
+      return T15.tuple(arr.elements.slice(startIdx, endIdx));
     }
-    return T12.array(arr.element);
+    return T15.array(arr.element);
   }
   if (callbackFn && callbackFn.kind === "union" && callbackFn.members.length > 0 && callbackFn.members.every((m) => m.kind === "function")) {
     return distributeOverUnion(callbackFn, (member) => {
       const r = evaluateArrayMethodValues(arr, method, [member, ...argVals.slice(1)]);
-      return r === null ? T12.unknown : r;
+      return r === null ? T15.unknown : r;
     });
   }
   if (!callbackFn || callbackFn.kind !== "function") {
-    if (method === "map") return arr.kind === "tuple" ? T12.tuple(arr.elements.map(() => T12.unknown)) : T12.array(T12.unknown);
-    if (method === "filter") return arr.kind === "tuple" ? T12.array(simplifyUnion4(arr.elements)) : arr;
-    if (method === "find") return arr.kind === "tuple" ? simplifyUnion4([...arr.elements, T12.undefined]) : simplifyUnion4([arr.element, T12.undefined]);
-    if (method === "some" || method === "every") return T12.boolean;
-    if (method === "reduce") return argVals[1] ?? T12.unknown;
-    if (method === "forEach") return T12.undefined;
-    if (method === "flatMap") return T12.array(T12.unknown);
+    if (method === "map") return arr.kind === "tuple" ? T15.tuple(arr.elements.map(() => T15.unknown)) : T15.array(T15.unknown);
+    if (method === "filter") return arr.kind === "tuple" ? T15.array(simplifyUnion8(arr.elements)) : arr;
+    if (method === "find") return arr.kind === "tuple" ? simplifyUnion8([...arr.elements, T15.undefined]) : simplifyUnion8([arr.element, T15.undefined]);
+    if (method === "some" || method === "every") return T15.boolean;
+    if (method === "reduce") return argVals[1] ?? T15.unknown;
+    if (method === "forEach") return T15.undefined;
+    if (method === "flatMap") return T15.array(T15.unknown);
     return null;
   }
   const fn = callbackFn;
+  const tagEl = (el, name) => {
+    const tagged = tagParamArg(el, name);
+    copyOrigin(el, tagged);
+    return tagged;
+  };
   if (method === "map") {
     if (arr.kind === "tuple") {
       const mapped = arr.elements.map(
-        (el, i) => callFunction(fn, [el, T12.literal(i), arr])
+        (el, i) => callFunction(fn, [tagEl(el, fn.params[0] ?? "item"), T15.literal(i), arr])
       );
-      return T12.tuple(mapped);
+      return T15.tuple(mapped);
     }
-    return T12.array(callFunction(fn, [arr.element, T12.number, arr]));
+    return T15.array(
+      callFunction(fn, [tagEl(arr.element, fn.params[0] ?? "item"), T15.number, arr])
+    );
   }
   if (method === "filter") {
     if (arr.kind === "tuple") {
       const kept = [];
       for (let i = 0; i < arr.elements.length; i++) {
-        const result = callFunction(fn, [arr.elements[i], T12.literal(i), arr]);
+        const result = callFunction(fn, [
+          tagEl(arr.elements[i], fn.params[0] ?? "item"),
+          T15.literal(i),
+          arr
+        ]);
         if (result.kind === "literal" && !result.value) continue;
         kept.push(arr.elements[i]);
       }
-      if (kept.length === 0) return T12.tuple([]);
-      return T12.array(simplifyUnion4(kept));
+      if (kept.length === 0) return T15.tuple([]);
+      return T15.array(simplifyUnion8(kept));
     }
-    return T12.array(arr.element);
+    return T15.array(arr.element);
   }
   if (method === "reduce") {
     const init = argVals[1];
     if (arr.kind === "tuple") {
-      let acc2 = init ?? arr.elements[0] ?? T12.unknown;
+      let acc2 = init ?? arr.elements[0] ?? T15.unknown;
       const startIdx = init ? 0 : 1;
       for (let i = startIdx; i < arr.elements.length; i++) {
-        acc2 = callFunction(fn, [acc2, arr.elements[i], T12.literal(i), arr]);
+        acc2 = callFunction(fn, [
+          acc2,
+          tagEl(arr.elements[i], fn.params[1] ?? "item"),
+          T15.literal(i),
+          arr
+        ]);
       }
       return acc2;
     }
-    const acc = init ?? arr.element;
-    const result = callFunction(fn, [acc, arr.element, T12.number, arr]);
-    return result;
+    const acc0 = init ?? arr.element;
+    let acc = acc0;
+    for (let i = 0; i < 6; i++) {
+      const next = callFunction(fn, [
+        acc,
+        tagEl(arr.element, fn.params[1] ?? "item"),
+        T15.number,
+        arr
+      ]);
+      if (typeValueEquals4(acc, next)) return next;
+      if (next.kind === "unknown") return acc;
+      acc = simplifyUnion8([acc, next]);
+    }
+    return acc;
   }
   if (method === "find") {
-    const elementType = arr.kind === "tuple" ? simplifyUnion4(arr.elements) : arr.element;
-    return simplifyUnion4([elementType, T12.undefined]);
+    const elementType = arr.kind === "tuple" ? simplifyUnion8(arr.elements) : arr.element;
+    return simplifyUnion8([elementType, T15.undefined]);
   }
   if (method === "some" || method === "every") {
     if (arr.kind === "tuple") {
       const results = arr.elements.map(
-        (el, i) => callFunction(fn, [el, T12.literal(i), arr])
+        (el, i) => callFunction(fn, [el, T15.literal(i), arr])
       );
       const allLiteral = results.every((r) => r.kind === "literal");
       if (allLiteral) {
         const boolVals = results.map((r) => !!r.value);
-        return T12.literal(method === "some" ? boolVals.some(Boolean) : boolVals.every(Boolean));
+        return T15.literal(method === "some" ? boolVals.some(Boolean) : boolVals.every(Boolean));
       }
     }
-    return T12.boolean;
+    return T15.boolean;
   }
   if (method === "forEach") {
     if (arr.kind === "tuple") {
-      arr.elements.forEach((el, i) => callFunction(fn, [el, T12.literal(i), arr]));
+      arr.elements.forEach((el, i) => callFunction(fn, [el, T15.literal(i), arr]));
     } else {
-      callFunction(fn, [arr.element, T12.number, arr]);
+      callFunction(fn, [arr.element, T15.number, arr]);
     }
-    return T12.undefined;
+    return T15.undefined;
   }
   if (method === "flatMap") {
     if (arr.kind === "tuple") {
       const results = [];
       for (let i = 0; i < arr.elements.length; i++) {
-        const r2 = callFunction(fn, [arr.elements[i], T12.literal(i), arr]);
+        const r2 = callFunction(fn, [arr.elements[i], T15.literal(i), arr]);
         if (r2.kind === "tuple") results.push(...r2.elements);
-        else if (r2.kind === "array") return T12.array(r2.element);
+        else if (r2.kind === "array") return T15.array(r2.element);
         else results.push(r2);
       }
-      return T12.tuple(results);
+      return T15.tuple(results);
     }
-    const r = callFunction(fn, [arr.element, T12.number, arr]);
-    if (r.kind === "tuple") return T12.array(simplifyUnion4(r.elements));
-    if (r.kind === "array") return T12.array(r.element);
-    return T12.array(r);
+    const r = callFunction(fn, [arr.element, T15.number, arr]);
+    if (r.kind === "tuple") return T15.array(simplifyUnion8(r.elements));
+    if (r.kind === "array") return T15.array(r.element);
+    return T15.array(r);
   }
   return null;
 }
@@ -4076,16 +4495,16 @@ function iterableSpreadValue(v) {
   if (v.kind === "instance" && v.className === "Set") {
     const values = exactSetValues(v);
     if (values) {
-      return values.length <= MAX_ITERABLE_SPREAD ? T12.tuple([...values]) : setValuesIterable(v);
+      return values.length <= MAX_ITERABLE_SPREAD ? T15.tuple([...values]) : setValuesIterable(v);
     }
     const t = v._typeArgs?.T;
-    return t && t.kind !== "unknown" ? T12.array(t) : void 0;
+    return t && t.kind !== "unknown" ? T15.array(t) : void 0;
   }
   if (v.kind === "instance" && v.className === "Map") {
     const entries = exactMapEntries(v);
     if (entries && entries.length > MAX_ITERABLE_SPREAD) {
       const ta = v._typeArgs ?? {};
-      return T12.array(T12.tuple([ta.K ?? T12.unknown, ta.V ?? T12.unknown]));
+      return T15.array(T15.tuple([ta.K ?? T15.unknown, ta.V ?? T15.unknown]));
     }
     return mapEntriesIterable(v);
   }
@@ -4099,7 +4518,7 @@ function evaluateForOf(node, iterable, env) {
       const memberResult = evaluateForOf(node, member, currentEnv);
       if (isReturn(memberResult)) {
         returnValues.push(memberResult.value);
-        return makeReturn(simplifyUnion4(returnValues));
+        return makeReturn(simplifyUnion8(returnValues));
       }
       if (isBranch(memberResult)) {
         returnValues.push(memberResult.returnedValue);
@@ -4107,9 +4526,9 @@ function evaluateForOf(node, iterable, env) {
       }
     }
     if (returnValues.length > 0) {
-      return makeBranch(simplifyUnion4(returnValues), currentEnv);
+      return makeBranch(simplifyUnion8(returnValues), currentEnv);
     }
-    return T12.undefined;
+    return T15.undefined;
   }
   if (iterable.kind === "tuple") {
     const returnValues = [];
@@ -4120,7 +4539,7 @@ function evaluateForOf(node, iterable, env) {
       const result = evaluate(node.body, loopEnv);
       if (isReturn(result)) {
         returnValues.push(result.value);
-        return makeReturn(simplifyUnion4(returnValues));
+        return makeReturn(simplifyUnion8(returnValues));
       }
       if (isBranch(result)) {
         returnValues.push(result.returnedValue);
@@ -4129,36 +4548,36 @@ function evaluateForOf(node, iterable, env) {
       if (loopSignalKind(result) === "break") break;
     }
     if (returnValues.length > 0) {
-      return makeBranch(simplifyUnion4(returnValues), currentEnv);
+      return makeBranch(simplifyUnion8(returnValues), currentEnv);
     }
-    return T12.undefined;
+    return T15.undefined;
   }
   if (iterable.kind === "array") {
     const loopEnv = env.fork();
     bindForLoopVar(node.left, iterable.element, loopEnv);
     const result = evaluate(node.body, loopEnv);
     if (isReturn(result)) return makeBranch(result.value, env);
-    return T12.undefined;
+    return T15.undefined;
   }
   if (iterable.kind === "instance" && iterable.className === "Set") {
     const values = exactSetValues(iterable);
     if (values && values.length > 0) {
-      return evaluateForOf(node, T12.tuple([...values]), env);
+      return evaluateForOf(node, T15.tuple([...values]), env);
     }
-    return T12.undefined;
+    return T15.undefined;
   }
   if (iterable.kind === "instance" && iterable.className === "Map") {
     const entries = exactMapEntries(iterable);
     if (entries && entries.length > 0) {
       return evaluateForOf(
         node,
-        T12.tuple(entries.map((e) => T12.tuple([e.key, e.value]))),
+        T15.tuple(entries.map((e) => T15.tuple([e.key, e.value]))),
         env
       );
     }
-    return T12.undefined;
+    return T15.undefined;
   }
-  return T12.undefined;
+  return T15.undefined;
 }
 function evaluateForIn(node, obj, env) {
   if (obj.kind === "object") {
@@ -4168,11 +4587,11 @@ function evaluateForIn(node, obj, env) {
       let currentEnv = env;
       for (const key of keys) {
         const loopEnv2 = currentEnv.extend({});
-        bindForLoopVar(node.left, T12.literal(key), loopEnv2);
+        bindForLoopVar(node.left, T15.literal(key), loopEnv2);
         const result = evaluate(node.body, loopEnv2);
         if (isReturn(result)) {
           returnValues.push(result.value);
-          return makeReturn(simplifyUnion4(returnValues));
+          return makeReturn(simplifyUnion8(returnValues));
         }
         if (isBranch(result)) {
           returnValues.push(result.returnedValue);
@@ -4181,15 +4600,15 @@ function evaluateForIn(node, obj, env) {
         if (loopSignalKind(result) === "break") break;
       }
       if (returnValues.length > 0) {
-        return makeBranch(simplifyUnion4(returnValues), currentEnv);
+        return makeBranch(simplifyUnion8(returnValues), currentEnv);
       }
-      return T12.undefined;
+      return T15.undefined;
     }
   }
   const loopEnv = env.fork();
-  bindForLoopVar(node.left, T12.string, loopEnv);
+  bindForLoopVar(node.left, T15.string, loopEnv);
   evaluate(node.body, loopEnv);
-  return T12.undefined;
+  return T15.undefined;
 }
 function bindForLoopVar(left, value, env) {
   if (left.type === "VariableDeclaration") {
@@ -4290,9 +4709,9 @@ function evaluateForStatement(node, env) {
     if (!env.update(name, val)) env.bind(name, val);
   }
   if (returnValues.length > 0) {
-    return makeBranch(simplifyUnion4(returnValues), env);
+    return makeBranch(simplifyUnion8(returnValues), env);
   }
-  return T12.undefined;
+  return T15.undefined;
 }
 function evaluateWhileStatement(node, env) {
   const returnValues = [];
@@ -4312,9 +4731,9 @@ function evaluateWhileStatement(node, env) {
     if (loopSignalKind(bodyResult) === "break") break;
   }
   if (returnValues.length > 0) {
-    return makeBranch(simplifyUnion4(returnValues), env);
+    return makeBranch(simplifyUnion8(returnValues), env);
   }
-  return T12.undefined;
+  return T15.undefined;
 }
 function evaluateDoWhileStatement(node, env) {
   const returnValues = [];
@@ -4334,9 +4753,9 @@ function evaluateDoWhileStatement(node, env) {
     if (tv.kind !== "literal") break;
   }
   if (returnValues.length > 0) {
-    return makeBranch(simplifyUnion4(returnValues), env);
+    return makeBranch(simplifyUnion8(returnValues), env);
   }
-  return T12.undefined;
+  return T15.undefined;
 }
 function moduleLabel(pathOrSpecifier) {
   const base = pathOrSpecifier.replace(/^.*\//, "");
@@ -4407,7 +4826,7 @@ function namespaceFromExportBindings(env) {
     exports[k === "__export_default" ? "default" : k.slice("__export_".length)] = v;
   }
   if (Object.keys(exports).length === 0) return null;
-  return T12.object(exports);
+  return T15.object(exports);
 }
 function commonJsExportsValue(moduleEnv) {
   if (moduleEnv.has("module")) {
@@ -4422,27 +4841,7 @@ function commonJsExportsValue(moduleEnv) {
       }
     }
   }
-  return T12.unknown;
-}
-function jsonToTypeValue(v) {
-  if (v === null) return T12.literal(null);
-  if (typeof v === "string") return T12.literal(v);
-  if (typeof v === "number") return T12.literal(v);
-  if (typeof v === "boolean") return T12.literal(v);
-  if (Array.isArray(v)) return T12.tuple(v.map(jsonToTypeValue));
-  if (typeof v === "object") {
-    const props = {};
-    for (const [k, val] of Object.entries(v)) {
-      Object.defineProperty(props, k, {
-        value: jsonToTypeValue(val),
-        enumerable: true,
-        writable: true,
-        configurable: true
-      });
-    }
-    return T12.object(props);
-  }
-  return T12.unknown;
+  return T15.unknown;
 }
 function evaluateRequireCall(node, _env) {
   const arg = node.arguments[0];
@@ -4453,7 +4852,7 @@ function evaluateRequireCall(node, _env) {
       loc: node.loc,
       reason: "require() with non-literal specifier"
     });
-    return T12.unknown;
+    return T15.unknown;
   }
   const specifier = arg.value;
   if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
@@ -4463,9 +4862,9 @@ function evaluateRequireCall(node, _env) {
       loc: node.loc,
       reason: `bare module specifier '${specifier}' is not resolved (npm packages unsupported)`
     });
-    return T12.unknown;
+    return T15.unknown;
   }
-  if (!currentModuleResolver) return T12.unknown;
+  if (!currentModuleResolver) return T15.unknown;
   const resolved = currentModuleResolver(specifier, currentFileDir);
   if (!resolved) {
     recordUnknown({
@@ -4474,7 +4873,7 @@ function evaluateRequireCall(node, _env) {
       loc: node.loc,
       reason: `Cannot resolve require('${specifier}'): no file at ${attemptedFullPath(currentFileDir, specifier)} (with or without .js/.ts/.mjs extension)`
     });
-    return T12.unknown;
+    return T15.unknown;
   }
   if ("json" in resolved && resolved.json !== void 0) {
     return jsonToTypeValue(resolved.json);
@@ -4498,15 +4897,15 @@ function evaluateImportDeclaration(node, env) {
           if (spec.type === "ImportSpecifier") {
             const importedName = spec.imported.type === "Identifier" ? spec.imported.name : null;
             if (importedName && mockModule.names.includes(importedName)) {
-              const val = mockEnv.has(`__export_${importedName}`) ? mockEnv.lookup(`__export_${importedName}`) : T12.unknown;
+              const val = mockEnv.has(`__export_${importedName}`) ? mockEnv.lookup(`__export_${importedName}`) : T15.unknown;
               env.bind(spec.local.name, val);
             } else if (importedName && originalEnv) {
-              const val = originalEnv.has(`__export_${importedName}`) ? originalEnv.lookup(`__export_${importedName}`) : T12.unknown;
+              const val = originalEnv.has(`__export_${importedName}`) ? originalEnv.lookup(`__export_${importedName}`) : T15.unknown;
               env.bind(spec.local.name, val);
             }
           } else if (spec.type === "ImportDefaultSpecifier") {
             const sourceEnv = originalEnv ?? mockEnv;
-            const val = sourceEnv.has(`__export_default`) ? sourceEnv.lookup(`__export_default`) : T12.unknown;
+            const val = sourceEnv.has(`__export_default`) ? sourceEnv.lookup(`__export_default`) : T15.unknown;
             env.bind(spec.local.name, val);
           } else if (spec.type === "ImportNamespaceSpecifier") {
             const exports = {};
@@ -4527,19 +4926,19 @@ function evaluateImportDeclaration(node, env) {
                 }
               }
             }
-            env.bind(spec.local.name, T12.object(exports));
+            env.bind(spec.local.name, T15.object(exports));
           }
         }
-        return T12.undefined;
+        return T15.undefined;
       }
       for (const spec of node.specifiers) {
         if (spec.type === "ImportDefaultSpecifier") {
-          const val = mockEnv.has(`__export_default`) ? mockEnv.lookup(`__export_default`) : T12.unknown;
+          const val = mockEnv.has(`__export_default`) ? mockEnv.lookup(`__export_default`) : T15.unknown;
           env.bind(spec.local.name, val);
         } else if (spec.type === "ImportSpecifier") {
           const importedName = spec.imported.type === "Identifier" ? spec.imported.name : null;
           if (importedName) {
-            const val = mockEnv.has(`__export_${importedName}`) ? mockEnv.lookup(`__export_${importedName}`) : T12.unknown;
+            const val = mockEnv.has(`__export_${importedName}`) ? mockEnv.lookup(`__export_${importedName}`) : T15.unknown;
             env.bind(spec.local.name, val);
           }
         } else if (spec.type === "ImportNamespaceSpecifier") {
@@ -4550,10 +4949,10 @@ function evaluateImportDeclaration(node, env) {
               exports[k.slice("__export_".length)] = v;
             }
           }
-          env.bind(spec.local.name, T12.object(exports));
+          env.bind(spec.local.name, T15.object(exports));
         }
       }
-      return T12.undefined;
+      return T15.undefined;
     }
     recordUnknown({
       kind: "global",
@@ -4567,20 +4966,20 @@ function evaluateImportDeclaration(node, env) {
     for (const spec of node.specifiers) {
       if (spec.type === "ImportDefaultSpecifier") {
         const defaultExport = envModule["default"];
-        env.bind(spec.local.name, defaultExport ?? T12.unknown);
+        env.bind(spec.local.name, defaultExport ?? T15.unknown);
       } else if (spec.type === "ImportSpecifier") {
         const importedName = spec.imported.type === "Identifier" ? spec.imported.name : null;
         if (importedName) {
-          env.bind(spec.local.name, envModule[importedName] ?? T12.unknown);
+          env.bind(spec.local.name, envModule[importedName] ?? T15.unknown);
         }
       } else if (spec.type === "ImportNamespaceSpecifier") {
         const { default: _default, ...rest } = envModule;
-        env.bind(spec.local.name, T12.object(rest));
+        env.bind(spec.local.name, T15.object(rest));
       }
     }
-    return T12.undefined;
+    return T15.undefined;
   }
-  if (!currentModuleResolver) return T12.undefined;
+  if (!currentModuleResolver) return T15.undefined;
   const resolved = currentModuleResolver(source, currentFileDir);
   if (!resolved) {
     if (source.startsWith(".") || source.startsWith("/")) {
@@ -4591,17 +4990,17 @@ function evaluateImportDeclaration(node, env) {
         reason: `Cannot resolve import '${source}': no file at ${attemptedFullPath(currentFileDir, source)} (with or without .js/.ts/.mjs extension)`
       });
     }
-    return T12.undefined;
+    return T15.undefined;
   }
   const moduleEnv = loadModuleEnv(resolved, node.loc);
   for (const spec of node.specifiers) {
     if (spec.type === "ImportDefaultSpecifier") {
-      const val = moduleEnv.has(`__export_default`) ? moduleEnv.lookup(`__export_default`) : T12.unknown;
+      const val = moduleEnv.has(`__export_default`) ? moduleEnv.lookup(`__export_default`) : T15.unknown;
       env.bind(spec.local.name, val);
     } else if (spec.type === "ImportSpecifier") {
       const importedName = spec.imported.type === "Identifier" ? spec.imported.name : null;
       if (importedName) {
-        const val = moduleEnv.has(`__export_${importedName}`) ? moduleEnv.lookup(`__export_${importedName}`) : T12.unknown;
+        const val = moduleEnv.has(`__export_${importedName}`) ? moduleEnv.lookup(`__export_${importedName}`) : T15.unknown;
         env.bind(spec.local.name, val);
       }
     } else if (spec.type === "ImportNamespaceSpecifier") {
@@ -4612,10 +5011,10 @@ function evaluateImportDeclaration(node, env) {
           exports[k.slice("__export_".length)] = v;
         }
       }
-      env.bind(spec.local.name, T12.object(exports));
+      env.bind(spec.local.name, T15.object(exports));
     }
   }
-  return T12.undefined;
+  return T15.undefined;
 }
 function evaluateClassDeclaration(node, env) {
   const className = node.id?.name ?? "<anonymous>";
@@ -4628,7 +5027,7 @@ function evaluateClassDeclaration(node, env) {
     const paramNames = member.params.map(
       (p) => p.type === "Identifier" ? p.name : `_p${Math.random().toString(36).slice(2, 6)}`
     );
-    const fnType = T12.fn(paramNames, member.body, env);
+    const fnType = T15.fn(paramNames, member.body, env);
     fnType._paramPatterns = member.params;
     fnType._name = `${className}.${methodName}`;
     if (member.async) fnType._async = true;
@@ -4639,33 +5038,33 @@ function evaluateClassDeclaration(node, env) {
       methods[methodName] = fnType;
     }
   }
-  const ctorFn = constructorFn ?? T12.fn([], { type: "BlockStatement", body: [], directives: [] }, env);
+  const ctorFn = constructorFn ?? T15.fn([], { type: "BlockStatement", body: [], directives: [] }, env);
   ctorFn._classInfo = { className, methods };
   if (node.id) {
     env.bind(className, ctorFn);
   }
-  return T12.undefined;
+  return T15.undefined;
 }
 function evaluateInstanceof(left, _right, rightNode, _env) {
   const className = rightNode.type === "Identifier" ? rightNode.name : null;
-  if (!className) return T12.boolean;
+  if (!className) return T15.boolean;
   return distributeOverUnion(left, (lv) => {
     if (lv.kind === "instance") {
-      const matches = lv.className === className || isSubtypeOf2(lv, T12.instanceOf(className));
-      return T12.literal(matches);
+      const matches = lv.className === className || isSubtypeOf2(lv, T15.instanceOf(className));
+      return T15.literal(matches);
     }
     const structural = builtinInstanceTest(lv, className);
-    if (structural !== void 0) return T12.literal(structural);
-    return T12.boolean;
+    if (structural !== void 0) return T15.literal(structural);
+    return T15.boolean;
   });
 }
 var PROMISE_SCAN_MAX_SITES = 16;
 var PROMISE_SCAN_MAX_NODES = 2e3;
 var _promiseCollectors = /* @__PURE__ */ new WeakSet();
 function makePromiseCollector(sink) {
-  const collector = T12.fnSig([T12.unknown], T12.undefined, T12.never, (args) => {
-    sink.push(args[0] ?? T12.undefined);
-    return T12.undefined;
+  const collector = T15.fnSig([T15.unknown], T15.undefined, T15.never, (args) => {
+    sink.push(args[0] ?? T15.undefined);
+    return T15.undefined;
   });
   _promiseCollectors.add(collector);
   return collector;
@@ -4722,7 +5121,7 @@ function evaluatePromiseExecutor(executor) {
       const cur = callEnv.lookup(name);
       if (isNullish(cur)) {
         const snap = preBodySnapshot.lookup(name);
-        if (!isNullish(snap) && snap !== T12.undefined) return snap;
+        if (!isNullish(snap) && snap !== T15.undefined) return snap;
       }
       return cur;
     },
@@ -4742,27 +5141,32 @@ function evaluatePromiseExecutor(executor) {
       resolveCollected.push(argVal);
     }
   }
-  return T12.promise(T12.union(...resolveCollected));
+  return T15.promise(T15.union(...resolveCollected));
 }
 function applyPromiseThenCallback(promiseValue, argVals) {
   const cb = argVals[0];
   if (!cb || cb.kind !== "function") return null;
   const result = callFunctionFull(cb, [promiseValue.value]).value;
-  return result.kind === "promise" ? result : T12.promise(result);
+  return result.kind === "promise" ? result : T15.promise(result);
 }
 function bindFunctionParams(fn, args, callEnv) {
   const paramPatterns = fn._paramPatterns;
   for (let i = 0; i < fn.params.length; i++) {
     const paramName = fn.params[i];
     if (paramName.startsWith("...")) {
-      const restValue = T12.tuple(args.slice(i));
+      const restValue = T15.tuple(args.slice(i));
       if (paramPatterns && paramPatterns[i]) {
         bindPattern(paramPatterns[i], restValue, callEnv);
       } else {
         callEnv.bind(paramName.slice(3), restValue);
       }
     } else {
-      const argVal = args[i] ?? T12.undefined;
+      let argVal = args[i] ?? T15.undefined;
+      {
+        const tagged = tagParamArg(argVal, paramName);
+        copyOrigin(argVal, tagged);
+        argVal = tagged;
+      }
       if (paramPatterns && paramPatterns[i]) {
         bindPattern(paramPatterns[i], argVal, callEnv);
       } else {
@@ -4771,7 +5175,7 @@ function bindFunctionParams(fn, args, callEnv) {
     }
   }
   if (fn._hasArguments) {
-    callEnv.bind("arguments", T12.tuple(args));
+    callEnv.bind("arguments", T15.tuple(args));
   }
 }
 function evaluateNewExpression(node, env) {
@@ -4779,8 +5183,8 @@ function evaluateNewExpression(node, env) {
   if (callee.type === "Identifier" && BUILTIN_ERROR_CLASSES.has(callee.name) && !env.has(callee.name)) {
     const argVals = evaluateArgs(node.arguments, env);
     if (isReturn(argVals) || isBranch(argVals) || isThrow(argVals)) return argVals;
-    const msgVal = argVals[0] ?? T12.undefined;
-    return T12.instanceOf(callee.name, { message: msgVal });
+    const msgVal = argVals[0] ?? T15.undefined;
+    return T15.instanceOf(callee.name, { message: msgVal });
   }
   if (callee.type === "Identifier" && callee.name === "Map" && !env.has("Map")) {
     const argVals = evaluateArgs(node.arguments, env);
@@ -4826,7 +5230,7 @@ function evaluateNewExpression(node, env) {
     if (executor && executor.kind === "function") {
       return evaluatePromiseExecutor(executor);
     }
-    return T12.promise(T12.unknown);
+    return T15.promise(T15.unknown);
   }
   if (callee.type === "MemberExpression" && !callee.computed) {
     const obj = callee.object;
@@ -4846,14 +5250,14 @@ function evaluateNewExpression(node, env) {
   if (protoClassName) {
     if (protoClassName === "Set") return createSetType();
     if (protoClassName === "Map") return createMapType();
-    if (protoClassName === "Array") return T12.array(T12.unknown);
-    return T12.instanceOf(protoClassName);
+    if (protoClassName === "Array") return T15.array(T15.unknown);
+    return T15.instanceOf(protoClassName);
   }
   const classNamespace = calleeVal.kind === "object" ? calleeVal._builtinName : void 0;
   if (classNamespace) {
-    if (classNamespace === "Array") return T12.array(T12.unknown);
-    if (classNamespace === "Object") return T12.object({});
-    return T12.instanceOf(classNamespace);
+    if (classNamespace === "Array") return T15.array(T15.unknown);
+    if (classNamespace === "Object") return T15.object({});
+    return T15.instanceOf(classNamespace);
   }
   if (calleeVal.kind === "function") {
     const argVals = evaluateArgs(node.arguments, env);
@@ -4862,7 +5266,7 @@ function evaluateNewExpression(node, env) {
     if (classInfo) {
       const instanceProps = {};
       const constructEnv = calleeVal.closure.extend({});
-      const thisObj = T12.object(instanceProps);
+      const thisObj = T15.object(instanceProps);
       constructEnv.bind("this", thisObj);
       bindFunctionParams(calleeVal, argVals, constructEnv);
       const result = evaluate(calleeVal.body, constructEnv);
@@ -4872,11 +5276,11 @@ function evaluateNewExpression(node, env) {
       for (const [k, v] of Object.entries(classInfo.methods)) {
         props[k] = v;
       }
-      return T12.instanceOf(classInfo.className, props);
+      return T15.instanceOf(classInfo.className, props);
     }
     return callFunction(calleeVal, argVals);
   }
-  return T12.unknown;
+  return T15.unknown;
 }
 function evaluateTryStatement(node, env) {
   const tryResult = evaluateStatements(node.block.body, env.fork());
@@ -4899,7 +5303,7 @@ function evaluateTryStatement(node, env) {
     if (isThrow(catchResult)) return catchResult;
     if (isReturn(catchResult)) {
       if (tryValue !== null && isReturn(tryValue)) {
-        return makeReturn(simplifyUnion4([tryValue.value, catchResult.value]));
+        return makeReturn(simplifyUnion8([tryValue.value, catchResult.value]));
       }
       return catchResult;
     }
@@ -4915,7 +5319,7 @@ function evaluateTryStatement(node, env) {
     return makeThrow(thrownType);
   }
   if (tryValue !== null) return tryValue;
-  return T12.undefined;
+  return T15.undefined;
 }
 function evaluateSwitchStatement(node, env) {
   const discriminant = evaluate(node.discriminant, env);
@@ -4949,9 +5353,9 @@ function evaluateSwitchStatement(node, env) {
       }
     }
     if (returnValues2.length > 0) {
-      return makeBranch(simplifyUnion4(returnValues2), env);
+      return makeBranch(simplifyUnion8(returnValues2), env);
     }
-    return T12.undefined;
+    return T15.undefined;
   }
   const returnValues = [];
   for (const caseNode of node.cases) {
@@ -4984,9 +5388,9 @@ function evaluateSwitchStatement(node, env) {
     }
   }
   if (returnValues.length > 0) {
-    return makeBranch(simplifyUnion4(returnValues), env);
+    return makeBranch(simplifyUnion8(returnValues), env);
   }
-  return T12.undefined;
+  return T15.undefined;
 }
 var MAX_CALL_DEPTH = 64;
 var MAX_TOTAL_CALLS = 2e5;
@@ -5013,7 +5417,7 @@ function recordFnResultObs(fn, value) {
 function observedResultFallback(fn) {
   const obs = _fnResultObs.get(fn);
   if (!obs || obs.length === 0) return void 0;
-  const union = collapseLiteralUnion(simplifyUnion4(obs), 4);
+  const union = collapseLiteralUnion(simplifyUnion8(obs), 4);
   return union.kind === "never" ? void 0 : union;
 }
 var cycleArgKeyCache = /* @__PURE__ */ new WeakMap();
@@ -5074,7 +5478,7 @@ function callBudgetExhausted(fnName, loc) {
     loc,
     reason: `recursive call truncated to unknown (cycle, depth > ${MAX_CALL_DEPTH}, or work budget)`
   });
-  return { value: T12.unknown, throws: T12.never };
+  return { value: T15.unknown, throws: T15.never };
 }
 function callFunctionFull(fn, args, thisVal) {
   const callKey = fnCallKey(fn, args, thisVal);
@@ -5102,7 +5506,7 @@ function callFunctionFull(fn, args, thisVal) {
 function callFunctionUnchecked(fn, args, thisVal) {
   const directReturn = fn._directReturn;
   if (directReturn) {
-    return { value: directReturn, throws: T12.never };
+    return { value: directReturn, throws: T15.never };
   }
   const sig = getFnSig(fn);
   if (sig) {
@@ -5121,28 +5525,28 @@ function callFunctionUnchecked(fn, args, thisVal) {
     if (cached !== void 0) {
       _unreachableRanges = savedUnreachable;
       if (cached === MEMO_IN_PROGRESS) {
-        return { value: T12.unknown, throws: T12.never };
+        return { value: T15.unknown, throws: T15.never };
       }
-      return { value: cached, throws: T12.never };
+      return { value: cached, throws: T15.never };
     }
     callMemo.set(memoKey, MEMO_IN_PROGRESS);
     const result2 = evaluate(fn.body, callEnv);
     _unreachableRanges = savedUnreachable;
-    const value2 = isReturn(result2) ? result2.value : isBranch(result2) ? result2.returnedValue : isThrow(result2) ? T12.never : result2;
-    const throws = isThrow(result2) ? result2.thrown : T12.never;
+    const value2 = isReturn(result2) ? result2.value : isBranch(result2) ? result2.returnedValue : isThrow(result2) ? T15.never : result2;
+    const throws = isThrow(result2) ? result2.thrown : T15.never;
     const throwLoc = isThrow(result2) ? result2.loc : void 0;
-    const wrapped2 = isAsync ? T12.promise(value2) : value2;
+    const wrapped2 = isAsync ? T15.promise(value2) : value2;
     callMemo.set(memoKey, wrapped2);
     return { value: wrapped2, throws, throwLoc };
   }
   const result = evaluate(fn.body, callEnv);
   _unreachableRanges = savedUnreachable;
   if (isThrow(result)) {
-    return { value: T12.never, throws: result.thrown, throwLoc: result.loc };
+    return { value: T15.never, throws: result.thrown, throwLoc: result.loc };
   }
   const value = isReturn(result) ? result.value : isBranch(result) ? result.returnedValue : result;
-  const wrapped = isAsync ? T12.promise(value) : value;
-  return { value: wrapped, throws: T12.never };
+  const wrapped = isAsync ? T15.promise(value) : value;
+  return { value: wrapped, throws: T15.never };
 }
 function callFunction(fn, args, thisVal) {
   return callFunctionFull(fn, args, thisVal).value;
@@ -5168,32 +5572,40 @@ function evaluateFunctionFull(fnNode, args, env) {
       const fnName = actualNode.id?.name;
       if (fnName) {
         const paramNames = actualNode.params.map(describeParam);
-        const selfRef = T12.fn(paramNames, actualNode.body, callEnv);
+        const selfRef = T15.fn(paramNames, actualNode.body, callEnv);
         selfRef._paramPatterns = actualNode.params;
         selfRef._name = fnName;
         if (isAsync) selfRef._async = true;
         callEnv.bind(fnName, selfRef);
       }
       for (let i = 0; i < actualNode.params.length; i++) {
-        bindPattern(actualNode.params[i], args[i] ?? T12.undefined, callEnv);
+        const pname = describeParam(actualNode.params[i]);
+        let argVal = args[i] ?? T15.undefined;
+        {
+          const tagged = tagParamArg(argVal, pname);
+          copyOrigin(argVal, tagged);
+          argVal = tagged;
+        }
+        bindPattern(actualNode.params[i], argVal, callEnv);
       }
       const result = evaluate(actualNode.body, callEnv);
-      if (isThrow(result)) return { value: T12.never, throws: result.thrown, throwLoc: result.loc };
+      if (isThrow(result)) return { value: T15.never, throws: result.thrown, throwLoc: result.loc };
       const value = isReturn(result) ? result.value : isBranch(result) ? result.returnedValue : result;
-      const wrapped = isAsync ? value.kind === "promise" ? value : T12.promise(value) : value;
-      return { value: wrapped, throws: T12.never };
+      const wrapped = isAsync ? value.kind === "promise" ? value : T15.promise(value) : value;
+      return { value: wrapped, throws: T15.never };
     } finally {
       _callDepth--;
     }
   }
-  return { value: T12.unknown, throws: T12.never };
+  return { value: T15.unknown, throws: T15.never };
 }
 function evaluateProgram(node, env) {
   bindCommonJsGlobals(env);
+  resetPhi();
   const result = evaluate(node, env);
   if (isReturn(result)) return result.value;
   if (isBranch(result)) return result.returnedValue;
-  if (isThrow(result)) return T12.never;
+  if (isThrow(result)) return T15.never;
   return result;
 }
 function getUnreachableRanges() {
@@ -5206,58 +5618,9 @@ function setCurrentFileDir(dir) {
   currentFileDir = dir;
 }
 
-// src/resolve-npm.ts
-import { readFileSync, existsSync } from "fs";
-import { resolve, join, dirname } from "path";
-function findNodeModules(startDir) {
-  let dir = resolve(startDir);
-  const root = resolve("/");
-  while (dir !== root) {
-    const nmPath = join(dir, "node_modules");
-    if (existsSync(nmPath)) return nmPath;
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-function resolveExportsNudo(exports, subpath) {
-  if (!exports || typeof exports !== "object") return null;
-  const entry = exports[subpath];
-  if (!entry) return null;
-  if (typeof entry === "object" && entry !== null && "nudo" in entry) {
-    const nudoEntry = entry["nudo"];
-    if (typeof nudoEntry === "string") return nudoEntry;
-  }
-  return null;
-}
-function resolveNpmNudo(source, fromDir) {
-  const isRelative = source.startsWith(".") || source.startsWith("/");
-  if (isRelative) return null;
-  const parts = source.startsWith("@") ? source.split("/").slice(0, 2) : source.split("/").slice(0, 1);
-  const pkgName = parts.join("/");
-  const subpath = source.slice(pkgName.length) || ".";
-  const nodeModules = findNodeModules(fromDir);
-  if (!nodeModules) return null;
-  const pkgJsonPath = join(nodeModules, pkgName, "package.json");
-  if (!existsSync(pkgJsonPath)) return null;
-  try {
-    const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-    const nudoEntry = resolveExportsNudo(pkg.exports, subpath);
-    if (nudoEntry) {
-      const resolved = resolve(dirname(pkgJsonPath), nudoEntry);
-      if (existsSync(resolved)) return resolved;
-    }
-  } catch {
-  }
-  return null;
-}
-
 export {
-  __require,
-  __commonJS,
-  __toESM,
   narrow,
+  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
   memberMayExistOn,
   setCurrentSource,
   resetMemo,
@@ -5281,6 +5644,5 @@ export {
   evaluateProgram,
   getUnreachableRanges,
   resetUnreachableRanges,
-  setCurrentFileDir,
-  resolveNpmNudo
+  setCurrentFileDir
 };