@nudojs/cli 0.2.1 → 0.3.0

package/src/evaluator.ts

@@ -3,7 +3,6 @@ import {
   type TypeValue,
   T,
   simplifyUnion,
-  applyBinaryOp,
   dispatchBinaryOp,
   dispatchMethod,
   dispatchProperty,
@@ -23,7 +22,22 @@ import {
 } from "@nudojs/core";
 import { extractInlineDirectives, type InlineDirective } from "@nudojs/parser";
 import { narrow } from "./narrowing.ts";
-import { PROMISE_STATIC_METHODS, evaluatePromiseStaticMethod, evaluatePromiseInstanceMethod } from "./builtins/builtin-promise.ts";
+import {
+  tryAbsObjectSpread,
+  tryAbsJoinObjects,
+  tryAbsUnary,
+  pushPhi,
+  popPhi,
+  currentPhi,
+  resetPhi,
+} from "./abs-route.ts";
+import {
+  evalBinaryValue,
+  distributeBinaryOverUnion,
+} from "./eval-binary.ts";
+import { phiFromTest, combinePhi } from "./phi-from-test.ts";
+import { tagParamArg } from "./term-registry.ts";
+import { evaluatePromiseStaticMethod, evaluatePromiseInstanceMethod } from "./builtins/builtin-promise.ts";
 import { MAP_INSTANCE_METHODS, createMapType, mapEntriesIterable, exactMapEntries } from "./builtins/builtin-map.ts";
 import { SET_INSTANCE_METHODS, createSetType, setValuesIterable, exactSetValues } from "./builtins/builtin-set.ts";
 import { REGEXP_INSTANCE_METHODS, createRegExpType } from "./builtins/builtin-regexp.ts";
@@ -39,427 +53,26 @@ import {
   createAbortControllerType,
 } from "./builtins/builtin-web.ts";
 import { WEAKMAP_INSTANCE_METHODS, WEAKSET_INSTANCE_METHODS, createWeakMapType, createWeakSetType } from "./builtins/builtin-weak.ts";
-import { SYMBOL_STATIC_METHODS, SYMBOL_STATIC_PROPS } from "./builtins/builtin-symbol.ts";
+import { SYMBOL_STATIC_PROPS } from "./builtins/builtin-symbol.ts";
 import { REFLECT_METHODS } from "./builtins/builtin-reflect.ts";
 import { INTL_DATETIMEFORMAT_METHODS, INTL_NUMBERFORMAT_METHODS, createDateTimeFormatType, createNumberFormatType } from "./builtins/builtin-intl.ts";
+import {
+  BUILTIN_ERROR_CLASSES,
+  BUILTIN_PROTOTYPE_CLASSES,
+  OBJECT_PROTOTYPE_METHODS,
+  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
+  builtinClassValue,
+  builtinPrototype,
+} from "./builtins/builtin-prototype.ts";
+import { BUILTIN_STATIC_METHODS, builtinInstanceTest, jsonToTypeValue } from "./builtins/builtin-static.ts";
+
 
-// Built-in JavaScript API type mappings
-// Namespace objects (e.g. Math.floor) and direct global values (e.g. parseInt)
-const BUILTIN_STATIC_METHODS: Record<string, Record<string, TypeValue> | TypeValue> = {
-  // Node CJS 库普遍依赖的 process 全局——缺它时 process.nextTick(cb) 走
-  // 未知全局 → undefined → no-method 假错（hoek wait 的 usage-site 执行）
-  process: {
-    nextTick: T.fn(["callback", "...args"], { type: "BlockStatement", body: [], directives: [] } as any, undefined as any),
-    env: T.object({}),
-    platform: T.string,
-    versions: T.object({}),
-    argv: T.array(T.string),
-    cwd: T.fn([], { type: "BlockStatement", body: [], directives: [] } as any, undefined as any),
-    exit: T.fn(["code"], { type: "BlockStatement", body: [], directives: [] } as any, undefined as any),
-    hrtime: T.fn(["time"], { type: "BlockStatement", body: [], directives: [] } as any, undefined as any),
-    stdout: T.instanceOf("Socket"),
-    stderr: T.instanceOf("Socket"),
-  },
-  Date: {
-    now: T.number,
-    parse: T.number,
-    UTC: T.number,
-  },
-  Math: {
-    random: T.number,
-    floor: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    ceil: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    round: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    abs: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    max: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    min: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    sqrt: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    pow: T.fn(["base", "exp"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    // Math 常量与 @nudo:env es 的 Math 定义对齐（env 绑定优先）；无 env
-    // 指令时也在此解析，避免 Math.PI 走 unknown-property。
-    PI: T.number,
-    E: T.number,
-    LN2: T.number,
-    LN10: T.number,
-    LOG2E: T.number,
-    LOG10E: T.number,
-    SQRT2: T.number,
-    SQRT1_2: T.number,
-  },
-  JSON: {
-    // JSON.parse(literal-string): evaluate with the real JSON.parse and
-    // re-encode through jsonToTypeValue, so fixture-style calls
-    // (`JSON.parse('{"a":1}')`) keep literal-level precision instead of
-    // poisoning downstream clone/deepEqual args with unknown. Degrades to
-    // the unknown fallback when the argument is not a literal string or
-    // 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: T.fnSig([T.string], T.unknown, T.never, (args) => {
-      const text = args[0];
-      if (text?.kind !== "literal" || typeof text.value !== "string") return undefined;
-      const reviver = args[1];
-      if (reviver && !(reviver.kind === "literal" && reviver.value === undefined)) return undefined;
-      try {
-        return jsonToTypeValue(JSON.parse(text.value));
-      } catch {
-        return undefined;
-      }
-    }),
-    stringify: T.string,
-  },
-  Object: {
-    keys: T.array(T.string),
-    values: T.array(T.unknown),
-    entries: T.array(T.tuple([T.string, T.unknown])),
-    assign: T.fnSig([T.unknown], T.unknown, T.never, (args) => {
-      // Object.assign(target, ...sources): later sources overwrite; a
-      // symbolic source keeps the symbolic unknown fallback.
-      const target = args[0];
-      if (target?.kind !== "object") return undefined;
-      const props: Record<string, TypeValue> = { ...target.properties };
-      for (const src of args.slice(1)) {
-        if (src?.kind !== "object") return undefined;
-        Object.assign(props, src.properties);
-      }
-      return T.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: T.fnSig([T.unknown], T.unknown, T.never, (args) => protoOfValue(args[0])),
-    create: T.fnSig([T.unknown], T.object({}), T.never, () => T.object({})),
-    setPrototypeOf: T.fnSig([T.unknown, T.unknown], T.unknown, T.never, (args) => args[0]),
-    defineProperty: T.fnSig([T.unknown, T.unknown, T.unknown], T.unknown, T.never, (args) => args[0]),
-    getOwnPropertyDescriptor: T.fnSig([T.unknown, T.unknown], T.union(T.object({}), T.undefined), T.never, (args) => {
-      const obj = args[0];
-      const key = args[1];
-      if (obj?.kind !== "object" && obj?.kind !== "instance") return T.undefined;
-      if (!key) return T.undefined;
-      if (key.kind === "literal" && typeof key.value === "string") {
-        const prop = hasOwnProp(obj.properties, key.value) ? obj.properties[key.value] : undefined;
-        if (!prop) return T.undefined;
-        return descriptorOf(prop);
-      }
-      if (key.kind === "primitive" && key.type === "string") {
-        const props = Object.keys(obj.properties);
-        if (props.length === 0) return T.undefined;
-        return descriptorOf(simplifyUnion(props.map((k) => obj.properties[k])));
-      }
-      return T.undefined;
-    }),
-  },
-  Buffer: {
-    from: T.fnSig([T.unknown], T.instanceOf("Buffer")),
-    alloc: T.fnSig([T.number], T.instanceOf("Buffer")),
-    concat: T.fnSig([T.unknown], T.instanceOf("Buffer")),
-    byteLength: T.fnSig([T.unknown], T.number),
-    isEncoding: T.fnSig([T.unknown], T.boolean),
-    isBuffer: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
-      const lit = builtinInstanceTest(args[0], "Buffer");
-      return lit === undefined ? undefined : T.literal(lit);
-    }),
-  },
-  Array: {
-    isArray: T.boolean,
-    from: T.array(T.unknown),
-  },
-  Number: {
-    isNaN: T.boolean,
-    isFinite: T.boolean,
-    parseInt: T.number,
-    parseFloat: T.number,
-    // Number 常量与 @nudo:env es 的 Number 定义对齐（env 绑定优先）；
-    // 均为 number（case 序列化器对非有限数返回 null，不产出字面量值）。
-    MAX_SAFE_INTEGER: T.number,
-    MIN_SAFE_INTEGER: T.number,
-    MAX_VALUE: T.number,
-    MIN_VALUE: T.number,
-    POSITIVE_INFINITY: T.number,
-    NEGATIVE_INFINITY: T.number,
-    NaN: T.number,
-    EPSILON: T.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: T.fnSig([T.number], T.string, T.never, (args) => {
-      const codes = literalCodeUnits(args);
-      return codes === null ? T.string : T.literal(String.fromCharCode(...codes));
-    }),
-    fromCodePoint: T.fnSig([T.number], T.string, T.never, (args) => {
-      const codes = literalCodeUnits(args);
-      if (codes === null) return T.string;
-      try {
-        return T.literal(String.fromCodePoint(...codes));
-      } catch {
-        return undefined;
-      }
-    }),
-  },
-  Promise: PROMISE_STATIC_METHODS,
-  Symbol: { ...SYMBOL_STATIC_METHODS, ...SYMBOL_STATIC_PROPS },
-  Reflect: REFLECT_METHODS as unknown as Record<string, TypeValue>,
-  Intl: {
-    DateTimeFormat: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    NumberFormat: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  },
-  parseInt: T.number,
-  parseFloat: T.number,
-  isNaN: T.boolean,
-  isFinite: T.boolean,
-  // 全局数值常量：与 @nudo:env es 的 globals 对齐（env 绑定优先）。无 env
-  // 指令时在此解析为 number——否则 Infinity/NaN 命中大写开头的未知全局
-  // 检测，触发 nudo:unknown-global 与 nudo:builtin-unknown 诊断。
-  Infinity: T.number,
-  NaN: T.number,
-};
 
-/** Harvest String.fromCharCode/fromCodePoint arguments: a list of number
- * literals ready for real evaluation, or null when any argument is
- * non-literal (symbolic → the caller keeps its plain string fallback).
- * An empty argument list yields [] (both statics return ""). */
-function literalCodeUnits(args: TypeValue[]): number[] | null {
-  const codes: number[] = [];
-  for (const a of args) {
-    if (a?.kind !== "literal" || typeof a.value !== "number") return null;
-    codes.push(a.value);
-  }
-  return codes;
-}
 
-/** `==`/`!=` 静态求值可用的字面量值：number/string/boolean/null/undefined
- * 这五种原始值走 JS 宽松相等的 ToNumber 强转路径，可直接用宿主 `==`
- * 求值（与规范一致）；bigint/symbol 无该路径，hit=false 交给调用方退化
- * 为 T.boolean。undefined 不能作哨兵值（它本身就是合法字面量值）。 */
-function looseLiteralValue(
-  tv: TypeValue,
-): { hit: boolean; v: number | string | boolean | null | undefined } {
-  if (tv.kind === "literal") {
-    const v = tv.value;
-    if (
-      typeof v === "number" ||
-      typeof v === "string" ||
-      typeof v === "boolean" ||
-      v === null ||
-      v === undefined
-    ) {
-      return { hit: true, v };
-    }
-  }
-  return { hit: false, v: undefined };
-}
 
-const BUILTIN_INSTANCE_METHODS: Record<string, Record<string, (...args: TypeValue[]) => TypeValue>> = {
-  Date: {
-    getTime: () => T.number,
-    getFullYear: () => T.number,
-    getMonth: () => T.number,
-    getDate: () => T.number,
-    getHours: () => T.number,
-    getMinutes: () => T.number,
-    getSeconds: () => T.number,
-    getMilliseconds: () => T.number,
-    toISOString: () => T.string,
-    toString: () => T.string,
-    valueOf: () => T.number,
-  },
-  WeakMap: WEAKMAP_INSTANCE_METHODS,
-  WeakSet: WEAKSET_INSTANCE_METHODS,
-  DateTimeFormat: INTL_DATETIMEFORMAT_METHODS,
-  NumberFormat: INTL_NUMBERFORMAT_METHODS,
-};
 
-const BUILTIN_ERROR_CLASSES = new Set([
-  "Error", "TypeError", "SyntaxError", "RangeError", "ReferenceError", "URIError", "EvalError",
-]);
-
-// Constructible built-in classes. A bare reference to one of these names
-// resolves to a namespace object (like the BUILTIN_STATIC_METHODS entries),
-// and `X.prototype` evaluates to an instance of X instead of degrading to
-// undefined/unknown.
-const BUILTIN_PROTOTYPE_CLASSES = new Set([
-  ...BUILTIN_ERROR_CLASSES,
-  "Date", "Object", "Map", "Set", "Promise", "RegExp", "Array", "Function",
-  "String", "Number", "Boolean", "Symbol", "WeakMap", "WeakSet", "Buffer",
-]);
-
-// Object.prototype members. Real property access reads through the
-// prototype chain, so every object-typed receiver materializes these —
-// destructuring `const { hasOwnProperty } = obj` yields a function (not
-// undefined) and `Object.prototype.hasOwnProperty` types as boolean.
-// Lookup must be own-property guarded: a plain `{}` record would otherwise
-// leak native JS functions (e.g. for "constructor") into the type system.
-//
-// toString/valueOf carry impls so the receiver (thisVal) shapes the result:
-// `Object.prototype.toString.call(x)` yields the brand literal
-// ('[object Map]', '[object Null]', ...) that Map-based type dispatch
-// (hoek internals.typeMap) keys on; valueOf returns its receiver.
-const OBJECT_PROTOTYPE_METHODS: Record<string, TypeValue> = {
-  hasOwnProperty: T.fnSig([T.unknown], T.boolean),
-  isPrototypeOf: T.fnSig([T.unknown], T.boolean),
-  propertyIsEnumerable: T.fnSig([T.unknown], T.boolean),
-  toString: T.fnSig([], T.string, T.never, (_args, thisVal) => objectToStringBrand(thisVal)),
-  toLocaleString: T.fnSig([], T.string),
-  valueOf: T.fnSig([], T.unknown, T.never, (_args, thisVal) => thisVal),
-};
 
-// Common prototype members approximated as unknown-result signatures
-// (mirrors the knownInstanceMethods fallback pattern). `X.prototype.m`
-// stays a callable function value instead of degrading to undefined.
-const BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS: Record<string, Record<string, TypeValue>> = {
-  Object: { ...OBJECT_PROTOTYPE_METHODS },
-  Array: {
-    push: T.fnSig([T.unknown], T.number),
-    pop: T.fnSig([], T.unknown),
-    shift: T.fnSig([], T.unknown),
-    unshift: T.fnSig([T.unknown], T.number),
-    slice: T.fnSig([T.number, T.number], T.array(T.unknown)),
-    splice: T.fnSig([T.number, T.number], T.array(T.unknown)),
-    concat: T.fnSig([T.unknown], T.array(T.unknown)),
-    join: T.fnSig([T.string], T.string),
-    indexOf: T.fnSig([T.unknown], T.number),
-    lastIndexOf: T.fnSig([T.unknown], T.number),
-    includes: T.fnSig([T.unknown], T.boolean),
-    map: T.fnSig([T.unknown], T.array(T.unknown)),
-    filter: T.fnSig([T.unknown], T.array(T.unknown)),
-    forEach: T.fnSig([T.unknown], T.undefined),
-    find: T.fnSig([T.unknown], T.unknown),
-    findIndex: T.fnSig([T.unknown], T.number),
-    some: T.fnSig([T.unknown], T.boolean),
-    every: T.fnSig([T.unknown], T.boolean),
-    reduce: T.fnSig([T.unknown, T.unknown], T.unknown),
-    sort: T.fnSig([T.unknown], T.array(T.unknown)),
-    reverse: T.fnSig([], T.array(T.unknown)),
-    toString: T.fnSig([], T.string),
-  },
-  Function: {
-    call: T.fnSig([T.unknown], T.unknown),
-    apply: T.fnSig([T.unknown, T.unknown], T.unknown),
-    bind: T.fnSig([T.unknown], T.unknown),
-    toString: T.fnSig([], T.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: T.fnSig([T.unknown], T.unknown, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.get(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    set: T.fnSig([T.unknown, T.unknown], T.unknown, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.set(args[0] ?? T.unknown, args[1] ?? T.unknown, thisVal ?? T.unknown)),
-    has: T.fnSig([T.unknown], T.boolean, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.has(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    delete: T.fnSig([T.unknown], T.boolean, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.delete(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    clear: T.fnSig([], T.undefined, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.clear(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    forEach: T.fnSig([T.unknown], T.undefined),
-    keys: T.fnSig([], T.array(T.unknown), T.never, (_args, thisVal) => MAP_INSTANCE_METHODS.keys(thisVal ?? T.unknown)),
-    values: T.fnSig([], T.array(T.unknown), T.never, (_args, thisVal) => MAP_INSTANCE_METHODS.values(thisVal ?? T.unknown)),
-    entries: T.fnSig([], T.array(T.tuple([T.unknown, T.unknown])), T.never, (_args, thisVal) => mapEntriesIterable(thisVal ?? T.unknown)),
-    toString: T.fnSig([], T.string),
-  },
-  Set: {
-    // Impl-routed like Map above (Set.prototype.values.call(s) ≡ s.values()).
-    add: T.fnSig([T.unknown], T.unknown, T.never, (args, thisVal) => SET_INSTANCE_METHODS.add(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    has: T.fnSig([T.unknown], T.boolean, T.never, (args, thisVal) => SET_INSTANCE_METHODS.has(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    delete: T.fnSig([T.unknown], T.boolean, T.never, (args, thisVal) => SET_INSTANCE_METHODS.delete(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    clear: T.fnSig([], T.undefined, T.never, (args, thisVal) => SET_INSTANCE_METHODS.clear(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    forEach: T.fnSig([T.unknown], T.undefined),
-    keys: T.fnSig([], T.array(T.unknown), T.never, (_args, thisVal) => SET_INSTANCE_METHODS.keys(thisVal ?? T.unknown)),
-    values: T.fnSig([], T.array(T.unknown), T.never, (_args, thisVal) => SET_INSTANCE_METHODS.values(thisVal ?? T.unknown)),
-    entries: T.fnSig([], T.array(T.tuple([T.unknown, T.unknown])), T.never, (_args, thisVal) => SET_INSTANCE_METHODS.entries(thisVal ?? T.unknown)),
-    toString: T.fnSig([], T.string),
-  },
-  WeakMap: {
-    get: T.fnSig([T.unknown], T.unknown),
-    set: T.fnSig([T.unknown, T.unknown], T.unknown),
-    has: T.fnSig([T.unknown], T.boolean),
-    delete: T.fnSig([T.unknown], T.boolean),
-    toString: T.fnSig([], T.string),
-  },
-  WeakSet: {
-    add: T.fnSig([T.unknown], T.unknown),
-    has: T.fnSig([T.unknown], T.boolean),
-    delete: T.fnSig([T.unknown], T.boolean),
-    toString: T.fnSig([], T.string),
-  },
-  Promise: {
-    then: T.fnSig([T.unknown], T.promise(T.unknown)),
-    catch: T.fnSig([T.unknown], T.promise(T.unknown)),
-    finally: T.fnSig([T.unknown], T.promise(T.unknown)),
-    toString: T.fnSig([], T.string),
-  },
-  Date: {
-    getTime: T.fnSig([], T.number),
-    valueOf: T.fnSig([], T.number),
-    toISOString: T.fnSig([], T.string),
-    toJSON: T.fnSig([], T.string),
-    toLocaleString: T.fnSig([], T.string),
-    toString: T.fnSig([], T.string),
-  },
-  RegExp: {
-    test: T.fnSig([T.string], T.boolean),
-    exec: T.fnSig([T.string], T.union(T.object({}), T.null)),
-    toString: T.fnSig([], T.string),
-  },
-  String: {
-    charAt: T.fnSig([T.number], T.string),
-    charCodeAt: T.fnSig([T.number], T.number),
-    indexOf: T.fnSig([T.string], T.number),
-    lastIndexOf: T.fnSig([T.string], T.number),
-    includes: T.fnSig([T.string], T.boolean),
-    startsWith: T.fnSig([T.string], T.boolean),
-    endsWith: T.fnSig([T.string], T.boolean),
-    slice: T.fnSig([T.number, T.number], T.string),
-    substring: T.fnSig([T.number, T.number], T.string),
-    toUpperCase: T.fnSig([], T.string),
-    toLowerCase: T.fnSig([], T.string),
-    trim: T.fnSig([], T.string),
-    replace: T.fnSig([T.unknown, T.string], T.string),
-    split: T.fnSig([T.string], T.array(T.string)),
-    toString: T.fnSig([], T.string),
-    valueOf: T.fnSig([], T.string),
-  },
-  Number: {
-    toFixed: T.fnSig([T.number], T.string),
-    toPrecision: T.fnSig([T.number], T.string),
-    valueOf: T.fnSig([], T.number),
-    toString: T.fnSig([T.number], T.string),
-  },
-  Boolean: {
-    valueOf: T.fnSig([], T.boolean),
-    toString: T.fnSig([], T.string),
-  },
-  Symbol: {
-    toString: T.fnSig([], T.string),
-    valueOf: T.fnSig([], T.symbol),
-  },
-  Buffer: {
-    equals: T.fnSig([T.unknown], T.boolean),
-    compare: T.fnSig([T.unknown], T.number),
-    toString: T.fnSig([T.unknown], T.string),
-    toJSON: T.fnSig([], T.unknown),
-  },
-  Error: {
-    toString: T.fnSig([], T.string),
-  },
-};
 
-// Memoized namespace values for built-in classes. Reference-stable so
-// `'x'.constructor === String` compares identical objects (typeValueEquals
-// falls back to reference equality for object kinds).
-const _builtinClassValues = new Map<string, TypeValue>();
-function builtinClassValue(name: string): TypeValue {
-  let v = _builtinClassValues.get(name);
-  if (v === undefined) {
-    v = T.object({});
-    (v as any)._builtinName = name;
-    _builtinClassValues.set(name, v);
-  }
-  return v;
-}
 
 // Wrapper-prototype fallback for primitive receivers: real JS auto-boxes
 // member access on primitives ('x'.constructor === String), so a named
@@ -503,109 +116,10 @@ function wrapperPrototypeMember(obj: TypeValue, propName: string): TypeValue | u
   return undefined;
 }
 
-// Cached `X.prototype` singletons. hoek-style modules assign
-// `exports.array = Array.prototype` and later compare
-// `baseProto === Types.buffer`: strict-equality on instances only stays
-// precise when every evaluation of `X.prototype` yields the same TypeValue.
-const BUILTIN_PROTOTYPE_SINGLETONS = new Map<string, TypeValue>();
 
-function builtinPrototype(className: string): TypeValue {
-  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 = T.instanceOf(className, { ...methods });
-    (proto as any)._builtinProto = className;
-    BUILTIN_PROTOTYPE_SINGLETONS.set(className, proto);
-  }
-  return proto;
-}
 
-// `Object.prototype.toString` brand string ('[object Map]', '[object Null]',
-// ...). Returns undefined when the receiver has no representable brand, so
-// the fnSig falls back to its plain `string` return type.
-function objectToStringBrand(v: TypeValue | undefined): TypeValue | undefined {
-  if (!v) return undefined;
-  if (v.kind === "union") {
-    const parts = v.members.map((m) => objectToStringBrand(m));
-    if (parts.some((p) => p === undefined)) return undefined;
-    return simplifyUnion(parts as TypeValue[]);
-  }
-  let base: TypeValue = v;
-  while (base.kind === "refined") base = base.base;
-  switch (base.kind) {
-    case "object": return T.literal("[object Object]");
-    case "array":
-    case "tuple": return T.literal("[object Array]");
-    case "function": return T.literal("[object Function]");
-    case "promise": return T.literal("[object Promise]");
-    case "instance": return T.literal(`[object ${base.className}]`);
-    case "literal": {
-      if (base.value === null) return T.literal("[object Null]");
-      if (base.value === undefined) return T.literal("[object Undefined]");
-      const t = typeof base.value;
-      return T.literal(`[object ${t === "number" ? "Number" : t === "string" ? "String" : "Boolean"}]`);
-    }
-    case "primitive": {
-      const brands: Record<string, string> = {
-        number: "Number", string: "String", boolean: "Boolean", bigint: "BigInt", symbol: "Symbol",
-      };
-      return T.literal(`[object ${brands[base.type] ?? "Object"}]`);
-    }
-    default: return undefined;
-  }
-}
-
-// Object.getPrototypeOf: map a receiver onto its class's cached prototype
-// singleton (plain objects → Object.prototype, arrays → Array.prototype,
-// instances → their class's prototype). Unrepresentable receivers degrade
-// to unknown.
-function protoOfValue(v: TypeValue | undefined): TypeValue {
-  if (!v) return T.unknown;
-  if (v.kind === "union") return simplifyUnion(v.members.map((m) => protoOfValue(m)));
-  let base: TypeValue = 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 T.unknown;
-  }
-}
 
-function descriptorOf(prop: TypeValue): TypeValue {
-  return T.object({
-    value: prop,
-    writable: T.boolean,
-    enumerable: T.boolean,
-    configurable: T.boolean,
-  });
-}
 
-// `x instanceof C` / `Buffer.isBuffer(x)` / `Array.isArray(x)` literal
-// answer for structurally-known receivers; undefined keeps the symbolic
-// fallback (boolean).
-function builtinInstanceTest(v: TypeValue | undefined, className: string): boolean | undefined {
-  if (!v) return undefined;
-  let base: TypeValue = v;
-  while (base.kind === "refined") base = base.base;
-  switch (base.kind) {
-    case "array":
-    case "tuple": return className === "Array" || className === "Object";
-    case "object": return className === "Object";
-    case "function": return className === "Function" || className === "Object";
-    case "promise": return className === "Promise" || className === "Object";
-    case "literal":
-    case "primitive": return false;
-    default: return undefined;
-  }
-}
 
 function arrayIsArrayLiteral(v: TypeValue): boolean | undefined {
   let base: TypeValue = v;
@@ -653,6 +167,18 @@ function definiteBoolean(tv: TypeValue): boolean | null {
   }
 }
 
+/**
+ * 分支合并：双对象先走 Abs join（sum-of-products / 槽位合并），
+ * 失败或非对象再 simplifyUnion。保证 join 代数接到 evaluator 主路径。
+ */
+function joinOrUnion(a: TypeValue, b: TypeValue): TypeValue {
+  if (a.kind === "object" && b.kind === "object") {
+    const joined = tryAbsJoinObjects(a, b);
+    if (joined) return joined;
+  }
+  return simplifyUnion([a, b]);
+}
+
 // Receiver-binding for thisVal-dependent Object.prototype methods
 // (toString/valueOf): `const v = obj.valueOf; v()` loses the member-access
 // receiver, so accesses off a concrete receiver return a copy whose impl
@@ -1094,6 +620,9 @@ export type CallRecord = {
   argTypes: TypeValue[];
   resultType: TypeValue;
   throws: TypeValue;
+  /** Line-relative. Per-fn cache replay shifts this by lineDelta — if you
+   *  add another position field (callee loc, arg loc), extend
+   *  shiftCallRecordLines in analyzer.ts in the same change. */
   callLoc?: { line: number; column: number };
   targetModule?: string;
   targetExport?: string;
@@ -1309,6 +838,13 @@ export function setProvenanceTracking(enabled: boolean): void {
   _provenanceEnabled = enabled;
 }
 
+/** 克隆 TypeValue 后拷贝 provenance（tagParamArg 会 clone，丢 origin 会导致 M5 回归） */
+function copyOrigin(from: TypeValue, to: TypeValue): void {
+  if (!_provenanceEnabled || !from || !to) return;
+  const o = _originMap.get(from);
+  if (o) _originMap.set(to, o);
+}
+
 function extractOrigin(
   tv: TypeValue | undefined,
 ): { line: number; column: number } | undefined {
@@ -1566,31 +1102,6 @@ function evaluateComputedMemberAccess(objVal: TypeValue, propVal: TypeValue, nod
   return result;
 }
 
-const MAX_UNION_PRODUCT = 50;
-
-function distributeBinaryOverUnion(
-  left: TypeValue,
-  right: TypeValue,
-  fn: (l: TypeValue, r: TypeValue) => TypeValue,
-): TypeValue {
-  if (left.kind === "union" && right.kind === "union") {
-    // Cap combinatorial blowup
-    if (left.members.length * right.members.length > MAX_UNION_PRODUCT) {
-      return T.unknown;
-    }
-    return simplifyUnion(
-      left.members.flatMap((l) => right.members.map((r) => fn(l, r))),
-    );
-  }
-  if (left.kind === "union") {
-    return simplifyUnion(left.members.map((l) => fn(l, right)));
-  }
-  if (right.kind === "union") {
-    return simplifyUnion(right.members.map((r) => fn(left, r)));
-  }
-  return fn(left, right);
-}
-
 let _unreachableRanges: SourceRange[] = [];
 
 function collectUnreachable(stmts: readonly Node[], fromIndex: number): void {
@@ -1815,66 +1326,39 @@ function evaluateNode(node: Node, env: Environment): EvalResult {
         return evaluateInstanceof(leftVal, rightVal, node.right, env);
       }
       if (node.operator === "in") {
-        // Literal `key in obj` / `Symbol.iterator in x` decisions; unions
-        // on either side distribute (mixed literals collapse per
-        // simplifyUnion), unknown receivers stay unknown.
         return distributeBinaryOverUnion(leftVal, rightVal, (l, r) => evaluateInMember(l, r));
       }
       if (node.operator === "===" || node.operator === "!==") {
-        // Prototype-singleton identity (`baseProto === Types.buffer`): the
-        // generic Op only literal-compares, so same-class instance pairs
-        // would collapse to boolean. Decide it when both sides are instances
-        // and at least one is a cached builtin prototype.
         const identity = builtinProtoIdentityEq(leftVal, rightVal);
         if (identity !== null) {
           return T.literal(node.operator === "===" ? identity : !identity);
         }
-        // Class-namespace identity (`x.constructor === Array`): memoized
-        // builtinClassValue objects compare by class name.
         const classIdentity = builtinClassIdentityEq(leftVal, rightVal);
         if (classIdentity !== null) {
           return T.literal(node.operator === "===" ? classIdentity : !classIdentity);
         }
       }
-      // `==`/`!=`：core 的 binaryOpMap 未收录这两个运算符（applyBinaryOp
-      // 会回落 unknown），在同一分派点补上——两操作数均为原始字面量
-      // （number/string/boolean/null/undefined）时按 JS 宽松相等语义
-      // （ToNumber 强转，如 "5" == 5 → true、null == undefined → true、
-      // NaN == NaN → false）直接求值出 boolean 字面量；任一操作数非字面量
-      // 时退化为 T.boolean。
-      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 T.literal(eq ? lv.v == rv.v : lv.v != rv.v);
-          return T.boolean;
-        });
-      }
-      return distributeBinaryOverUnion(leftVal, rightVal, (l, r) =>
-        dispatchBinaryOp(node.operator, l, r),
-      );
+
+      // 统一二元：代数优先 → 宽松相等 → 外延 Ops
+      const bin = evalBinaryValue(node.operator, leftVal, rightVal);
+      if (bin !== undefined) return bin;
+      return T.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));
-      }
+      // 一元语言表面经代数（typeof / ! / -）
+      const unary = tryAbsUnary(node.operator, argVal);
+      if (unary !== undefined) return unary;
       if (node.operator === "!") {
+        // 代数未接住：对象恒真等 host 知识
         return distributeOverUnion(argVal, (v) => {
-          // Object-ish receivers are statically truthy: `!ref` must resolve
-          // to literal false or enclosing `if (!ref || …)` guards explore
-          // both branches and the ref-reassigning branch poisons the loop.
           const decided = definiteBoolean(v);
           if (decided !== null) return T.literal(!decided);
           return Ops.not(v);
         });
       }
-      if (node.operator === "-") {
-        return distributeOverUnion(argVal, (v) => Ops.neg(v));
-      }
       return T.unknown;
     }
 
@@ -1964,7 +1448,7 @@ function evaluateNode(node: Node, env: Environment): EvalResult {
       const aResult = evaluate(node.alternate, falseEnv);
       const cVal = isReturn(cResult) ? cResult.value : isBranch(cResult) ? cResult.returnedValue : isThrow(cResult) ? T.never : cResult;
       const aVal = isReturn(aResult) ? aResult.value : isBranch(aResult) ? aResult.returnedValue : isThrow(aResult) ? T.never : aResult;
-      return simplifyUnion([cVal, aVal]);
+      return joinOrUnion(cVal, aVal);
     }
 
     case "IfStatement": {
@@ -1973,6 +1457,9 @@ function evaluateNode(node: Node, env: Environment): EvalResult {
       const testVal = evaluate(test, env);
       if (isReturn(testVal) || isBranch(testVal) || isThrow(testVal)) return testVal;
 
+      // Kernel Φ：从测试表达式提取约束，真/假分支分别合取
+      const phis = phiFromTest(test);
+
       if (testVal.kind === "literal") {
         if (testVal.value) {
           if (node.alternate?.loc) {
@@ -1981,7 +1468,12 @@ function evaluateNode(node: Node, env: Environment): EvalResult {
               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({
@@ -1989,26 +1481,52 @@ function evaluateNode(node: Node, env: Environment): EvalResult {
             end: { line: node.consequent.loc.end.line, column: node.consequent.loc.end.column },
           });
         }
-        return node.alternate
-          ? evaluate(node.alternate, falseEnv)
-          : T.undefined;
+        if (!node.alternate) return T.undefined;
+        pushPhi(combinePhi(currentPhi(), phis.whenFalse));
+        try {
+          return evaluate(node.alternate, falseEnv);
+        } finally {
+          popPhi();
+        }
       }
       // Object-ish / otherwise-decidable tests pick their branch statically
       // (e.g. `if (proto && proto.isImmutable)` once && resolves).
       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();
+          }
+        }
+        if (!node.alternate) return T.undefined;
+        pushPhi(combinePhi(currentPhi(), phis.whenFalse));
+        try {
+          return evaluate(node.alternate, falseEnv);
+        } finally {
+          popPhi();
         }
-        return node.alternate
-          ? evaluate(node.alternate, falseEnv)
-          : T.undefined;
       }
 
-      const consequentResult = evaluate(node.consequent, trueEnv);
-      const alternateResult = node.alternate
-        ? evaluate(node.alternate, falseEnv)
-        : null;
+      // 两边都探索：分别用各自 Φ
+      pushPhi(combinePhi(currentPhi(), phis.whenTrue));
+      let consequentResult: EvalResult;
+      try {
+        consequentResult = evaluate(node.consequent, trueEnv);
+      } finally {
+        popPhi();
+      }
+      pushPhi(combinePhi(currentPhi(), phis.whenFalse));
+      let alternateResult: EvalResult | null = null;
+      try {
+        alternateResult = node.alternate
+          ? evaluate(node.alternate, falseEnv)
+          : null;
+      } finally {
+        popPhi();
+      }
 
       const cReturns = isReturn(consequentResult);
       const cBranches = isBranch(consequentResult);
@@ -2033,21 +1551,21 @@ function evaluateNode(node: Node, env: Environment): EvalResult {
       }
 
       if (aThrows) {
-        const cVal = cReturns ? consequentResult.value
-          : cBranches ? consequentResult.returnedValue
+        const cVal = cReturns ? (consequentResult as ReturnSignal).value
+          : cBranches ? (consequentResult as BranchSignal).returnedValue
           : consequentResult as TypeValue;
         return makeBranch(cVal, trueEnv);
       }
 
-      const cVal = cReturns ? consequentResult.value
-        : cBranches ? consequentResult.returnedValue
+      const cVal = cReturns ? (consequentResult as ReturnSignal).value
+        : cBranches ? (consequentResult as BranchSignal).returnedValue
         : consequentResult as TypeValue;
       const aVal = aReturns ? (alternateResult as ReturnSignal).value
         : aBranches ? (alternateResult as BranchSignal).returnedValue
         : alternateResult as TypeValue | null;
 
       if (cReturns && aReturns) {
-        return makeReturn(simplifyUnion([cVal, aVal!]));
+        return makeReturn(joinOrUnion(cVal, aVal!));
       }
 
       if (cReturns && !node.alternate) {
@@ -2056,7 +1574,7 @@ function evaluateNode(node: Node, env: Environment): EvalResult {
 
       if (cReturns && node.alternate) {
         if (aReturns) {
-          return makeReturn(simplifyUnion([cVal, aVal!]));
+          return makeReturn(joinOrUnion(cVal, aVal!));
         }
         return makeBranch(cVal, falseEnv);
       }
@@ -2115,7 +1633,7 @@ function evaluateNode(node: Node, env: Environment): EvalResult {
           if (leftVal && leftVal.kind !== "unknown") {
             // Extract the binary operator (e.g., "+=" -> "+")
             const binaryOp = node.operator.slice(0, -1);
-            val = dispatchBinaryOp(binaryOp, leftVal, rightVal);
+            val = evalBinaryValue(binaryOp, leftVal, rightVal) ?? T.unknown;
           }
         }
 
@@ -2761,6 +2279,15 @@ function evaluateNode(node: Node, env: Environment): EvalResult {
         } else if (prop.type === "SpreadElement") {
           const spreadVal = evaluate(prop.argument, env);
           if (isReturn(spreadVal) || isBranch(spreadVal) || isThrow(spreadVal)) return spreadVal;
+          // M4：代数 spread（保留字面量/term）；失败回退 Object.assign
+          const absSpread = tryAbsObjectSpread(T.object(props), spreadVal);
+          if (absSpread !== undefined && absSpread.kind === "object") {
+            // 合并到 props 继续处理后续属性
+            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") {
@@ -3996,23 +3523,36 @@ function evaluateArrayMethodValues(
 
   const fn = callbackFn as TypeValue & { kind: "function" };
 
+  // HOF：给回调元素挂 term 身份，使 Φ 中的约束可传播到 map/reduce 体
+  const tagEl = (el: TypeValue, name: string): TypeValue => {
+    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, T.literal(i), arr]),
+        callFunction(fn, [tagEl(el, fn.params[0] ?? "item"), T.literal(i), arr]),
       );
       return T.tuple(mapped);
     }
-    return T.array(callFunction(fn, [arr.element, T.number, arr]));
+    return T.array(
+      callFunction(fn, [tagEl(arr.element, fn.params[0] ?? "item"), T.number, arr]),
+    );
   }
 
   if (method === "filter") {
     if (arr.kind === "tuple") {
       const kept: TypeValue[] = [];
       for (let i = 0; i < arr.elements.length; i++) {
-        const result = callFunction(fn, [arr.elements[i], T.literal(i), arr]);
+        const result = callFunction(fn, [
+          tagEl(arr.elements[i]!, fn.params[0] ?? "item"),
+          T.literal(i),
+          arr,
+        ]);
         if (result.kind === "literal" && !result.value) continue;
-        kept.push(arr.elements[i]);
+        kept.push(arr.elements[i]!);
       }
       if (kept.length === 0) return T.tuple([]);
       return T.array(simplifyUnion(kept));
@@ -4026,17 +3566,30 @@ function evaluateArrayMethodValues(
       let acc = init ?? arr.elements[0] ?? T.unknown;
       const startIdx = init ? 0 : 1;
       for (let i = startIdx; i < arr.elements.length; i++) {
-        acc = callFunction(fn, [acc, arr.elements[i], T.literal(i), arr]);
+        acc = callFunction(fn, [
+          acc,
+          tagEl(arr.elements[i]!, fn.params[1] ?? "item"),
+          T.literal(i),
+          arr,
+        ]);
       }
       return acc;
     }
-    // For arrays, we can't iterate all elements, but we can call the function
-    // with the accumulator and element type to infer the result type
-    const acc = init ?? arr.element;
-    const result = callFunction(fn, [acc, arr.element, T.number, arr]);
-    // If the result is the same type as the accumulator, it's likely correct
-    // (e.g., number + number = number)
-    return result;
+    // 抽象数组：不动点迭代（代数纪律）。unknown 不 join 进 acc。
+    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"),
+        T.number,
+        arr,
+      ]);
+      if (typeValueEquals(acc, next)) return next;
+      if (next.kind === "unknown") return acc;
+      acc = simplifyUnion([acc, next]);
+    }
+    return acc;
   }
 
   if (method === "find") {
@@ -4543,31 +4096,6 @@ function commonJsExportsValue(moduleEnv: Environment): TypeValue {
   return T.unknown;
 }
 
-/** JSON 值 → TypeValue（字面量级精确：package.json 版本号等成为 string 字面量） */
-function jsonToTypeValue(v: unknown): TypeValue {
-  if (v === null) return T.literal(null);
-  if (typeof v === "string") return T.literal(v);
-  if (typeof v === "number") return T.literal(v);
-  if (typeof v === "boolean") return T.literal(v);
-  if (Array.isArray(v)) return T.tuple(v.map(jsonToTypeValue));
-  if (typeof v === "object") {
-    const props: Record<string, TypeValue> = {};
-    for (const [k, val] of Object.entries(v)) {
-      // Define-as-own: plain assignment would let a "__proto__" key trip
-      // the setter on the props record (dropping it and corrupting the
-      // record's prototype) — JSON.parse creates an own property, and
-      // hoek's prototype-poisoning fixtures exercise exactly that key.
-      Object.defineProperty(props, k, {
-        value: jsonToTypeValue(val),
-        enumerable: true,
-        writable: true,
-        configurable: true,
-      });
-    }
-    return T.object(props);
-  }
-  return T.unknown;
-}
 
 function evaluateRequireCall(node: Node & { type: "CallExpression" }, _env: Environment): EvalResult {  const arg = (node.arguments as Node[])[0];
   if (!arg || arg.type !== "StringLiteral") {
@@ -4980,7 +4508,12 @@ function bindFunctionParams(
         callEnv.bind(paramName.slice(3), restValue); // Remove "..." prefix
       }
     } else {
-      const argVal = args[i] ?? T.undefined;
+      let argVal = args[i] ?? T.undefined;
+      {
+        const tagged = tagParamArg(argVal, paramName);
+        copyOrigin(argVal, tagged);
+        argVal = tagged;
+      }
       if (paramPatterns && paramPatterns[i]) {
         bindPattern(paramPatterns[i], argVal, callEnv);
       } else {
@@ -5582,7 +5115,14 @@ export function evaluateFunctionFull(
         callEnv.bind(fnName, selfRef);
       }
       for (let i = 0; i < actualNode.params.length; i++) {
-        bindPattern(actualNode.params[i], args[i] ?? T.undefined, callEnv);
+        const pname = describeParam(actualNode.params[i]!);
+        let argVal = args[i] ?? T.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: T.never, throws: result.thrown, throwLoc: result.loc };
@@ -5603,6 +5143,7 @@ export function evaluateFunctionFull(
 
 export function evaluateProgram(node: Node, env: Environment): TypeValue {
   bindCommonJsGlobals(env);
+  resetPhi();
   const result = evaluate(node, env);
   if (isReturn(result)) return result.value;
   if (isBranch(result)) return result.returnedValue;