@nudojs/cli 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/cli",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "CLI and evaluator API for the Nudo type inference engine",
   "type": "module",
   "license": "MIT",
@@ -12,17 +12,23 @@
     "dts",
     "abstract-interpretation"
   ],
-  "main": "src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./evaluator": "./src/evaluator-api.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./evaluator": {
+      "types": "./dist/evaluator-api.d.ts",
+      "default": "./dist/evaluator-api.js"
+    }
   },
   "bin": {
-    "nudo": "src/index.ts"
+    "nudo": "./dist/index.js"
   },
   "files": [
-    "src",
-    "!src/__tests__"
+    "dist"
   ],
   "repository": {
     "type": "git",
@@ -38,13 +44,14 @@
   },
   "dependencies": {
     "commander": "^13.0.0",
-    "@nudojs/core": "0.3.0",
-    "@nudojs/parser": "0.3.0",
-    "@nudojs/service": "0.3.0",
-    "@nudojs/env": "0.2.1",
-    "@nudojs/harvester": "0.2.0"
+    "@nudojs/core": "0.3.1",
+    "@nudojs/parser": "0.3.1",
+    "@nudojs/env": "0.2.2",
+    "@nudojs/service": "0.3.1",
+    "@nudojs/harvester": "0.2.1"
   },
   "scripts": {
-    "build": "tsup"
+    "build": "tsup",
+    "build:lib": "tsup src/evaluator-api.ts --format esm --dts"
   }
 }

package/src/abs-route.ts

@@ -1,273 +0,0 @@
-/**
- * TypeValue IR ⇄ Abs 代数的路由。
- *
- * 唯一计算路径：算术/比较/相等/一元语言表面先走 Abs；
- * 仅 refined 宿主扩展（/ % 自定义 ops、方法表）与代数无法建模的操作数才回落。
- */
-
-import type { TypeValue } from "@nudojs/core";
-import {
-  typeValueToAbs,
-  absToTypeValue,
-  simplifyUnion,
-  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,
-  type Abs,
-  type Pred,
-  pTrue,
-  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";
-import { getTerm, getPred } from "./term-registry.ts";
-
-export { currentPhi, pushPhi, popPhi, resetPhi, withPhiConstraint, describePhi };
-
-const ARITH_OPS = new Set(["+", "-", "*", "/", "%"]);
-const CMP_OPS = new Set(["<", "<=", ">", ">="]);
-const EQ_OPS = new Set(["===", "!=="]);
-const UNARY_OPS = new Set(["typeof", "!", "-"]);
-
-function isNumericOperand(tv: TypeValue): boolean {
-  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: TypeValue): boolean {
-  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: TypeValue): boolean {
-  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;
-}
-
-/**
- * 宿主 refinement 自定义了该运算 → 让位。
- * 仅限代数未覆盖的运算（/ %）：template 的 + 等仍走代数（concatString）。
- */
-function hasCustomRefinementOp(tv: TypeValue, op: string): boolean {
-  if (op !== "/" && op !== "%") return false;
-  let cur: TypeValue | undefined = tv;
-  while (cur && cur.kind === "refined") {
-    if (cur.refinement.ops?.[op]) return true;
-    cur = cur.base;
-  }
-  return false;
-}
-
-/** `+` 可接受：双数值；或任一侧 string/template（拼接） */
-function canAdd(left: TypeValue, right: TypeValue): boolean {
-  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;
-}
-
-/**
- * 带 term 旁路的 TypeValue → Abs。
- * range refined 编码为 term 上的 Pred（唯一约束通道），不再靠 refinement.ops。
- */
-function toAbsWithTerms(tv: TypeValue): Abs {
-  const base = typeValueToAbs(tv);
-  const term = getTerm(tv);
-  const pred = getPred(tv);
-  let abs: 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: Pred[] = [];
-    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 : undefined;
-      abs = makeAbs(
-        abs.shape,
-        abs.term,
-        existing ? predAnd(existing, ...facts) : predAnd(...facts),
-        abs.conf,
-      );
-    }
-  }
-  return abs;
-}
-
-/**
- * 代数计算二元算术/比较/相等。
- * - union：逐成员代数后 simplifyUnion（约束不丢）
- * - undefined = 不可处理 → 调用方走 refined 扩展 / 形状兜底
- */
-export function tryAbsBinary(
-  op: string,
-  left: TypeValue,
-  right: TypeValue,
-): TypeValue | undefined {
-  if (!ARITH_OPS.has(op) && !CMP_OPS.has(op) && !EQ_OPS.has(op)) return undefined;
-
-  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: TypeValue[] = [];
-    for (const l of ls) {
-      for (const r of rs) {
-        const one = tryAbsBinary(op, l, r);
-        if (one === undefined) return undefined;
-        results.push(one);
-      }
-    }
-    return simplifyUnion(results);
-  }
-
-  if (hasCustomRefinementOp(left, op) || hasCustomRefinementOp(right, op)) {
-    return undefined;
-  }
-
-  if (op === "+") {
-    if (!canAdd(left, right)) return undefined;
-  } else if (op === "-" || op === "*" || op === "/" || op === "%") {
-    if (!isNumericOperand(left) || !isNumericOperand(right)) return undefined;
-  } else if (op === "===" || op === "!==") {
-    // 任意操作数：先 strictEqAbs（字面量 / nullish / 同 var）
-  } else {
-    // 比较：数值或字符串
-    if (!isComparableOperand(left) || !isComparableOperand(right)) return undefined;
-  }
-
-  try {
-    const la = toAbsWithTerms(left);
-    const ra = toAbsWithTerms(right);
-    const phi = currentPhi();
-
-    if (op === "===" || op === "!==") {
-      const eq = kStrictEq(la, ra);
-      if (eq !== undefined) {
-        return absToTypeValue(op === "===" ? boolLit(eq) : boolLit(!eq));
-      }
-      // 无法判定：数值同型走 cmp 挂 pred；否则交还调用方
-      if (isNumericOperand(left) && isNumericOperand(right)) {
-        return absToTypeValue(kCmp(op === "===" ? "eq" : "ne", la, ra, phi));
-      }
-      return undefined;
-    }
-
-    let result: Abs;
-    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 undefined;
-
-    return absToTypeValue(result);
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * 一元语言表面经代数：typeof / ! / -。
- * 返回 undefined 表示调用方自行处理（union 分发等）。
- */
-export function tryAbsUnary(
-  op: string,
-  operand: TypeValue,
-): TypeValue | undefined {
-  if (!UNARY_OPS.has(op)) return undefined;
-  if (operand.kind === "union") {
-    const outs: TypeValue[] = [];
-    for (const m of operand.members) {
-      const one = tryAbsUnary(op, m);
-      if (one === undefined) return undefined;
-      outs.push(one);
-    }
-    return simplifyUnion(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 undefined;
-      return absToTypeValue(kNeg(a, currentPhi()));
-    }
-    return undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * 对象 spread 经代数（右侧覆盖，保留字面量）。
- * 返回 undefined 表示走 Object.assign 路径。
- */
-export function tryAbsObjectSpread(
-  base: TypeValue,
-  over: TypeValue,
-): TypeValue | undefined {
-  if (base.kind !== "object" && base.kind !== "union") return undefined;
-  if (over.kind !== "object" && over.kind !== "union") return undefined;
-  try {
-    const ba = toAbsWithTerms(base);
-    const oa = toAbsWithTerms(over);
-    const r = kSpread(ba, oa);
-    return absToTypeValue(r);
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * 对象 join（异 key 保持 sum，不折 optional）。
- */
-export function tryAbsJoinObjects(
-  a: TypeValue,
-  b: TypeValue,
-): TypeValue | undefined {
-  if (a.kind !== "object" || b.kind !== "object") return undefined;
-  try {
-    const r = kJoinAbs(toAbsWithTerms(a), toAbsWithTerms(b));
-    return absToTypeValue(r);
-  } catch {
-    return undefined;
-  }
-}

package/src/builtins/builtin-intl.ts

@@ -1,17 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const INTL_DATETIMEFORMAT_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  format: () => T.string,
-};
-
-export const INTL_NUMBERFORMAT_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  format: () => T.string,
-};
-
-export function createDateTimeFormatType(): TypeValue {
-  return T.instanceOf("DateTimeFormat", {});
-}
-
-export function createNumberFormatType(): TypeValue {
-  return T.instanceOf("NumberFormat", {});
-}

package/src/builtins/builtin-map.ts

@@ -1,174 +0,0 @@
-import { type TypeValue, T, simplifyUnion, typeValueEquals } from "@nudojs/core";
-
-// Literal/instance keys recorded at construction (`new Map([['k', v]])`) or
-// via set() — precise enough for typeValueEquals lookup. Symbolic keys are
-// skipped: they cannot be definitely matched, so get() falls back to the
-// V | undefined approximation.
-export type MapEntry = { key: TypeValue; value: TypeValue };
-
-function entryKeyTrackable(key: TypeValue | undefined): boolean {
-  return key?.kind === "literal" || key?.kind === "instance";
-}
-
-// Union keys distribute: every member hitting → union of values, every
-// member missing → undefined, mixed → values | undefined.
-function lookupEntries(entries: MapEntry[], key: TypeValue): TypeValue | null {
-  if (key.kind === "union") {
-    const results = key.members.map((m) => lookupEntries(entries, m));
-    if (results.some((r) => r === null)) return null;
-    return simplifyUnion(results as TypeValue[]);
-  }
-  if (!entryKeyTrackable(key)) return null;
-  const hit = entries.find((e) => typeValueEquals(e.key, key));
-  return hit ? hit.value : T.undefined;
-}
-
-export const MAP_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  get: (key: TypeValue, map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries) {
-      const looked = lookupEntries(entries, key);
-      if (looked !== null) return looked;
-    }
-    const typeArgs = (map as any)?._typeArgs;
-    if (typeArgs?.V) return T.union(typeArgs.V, T.undefined);
-    // Untyped receiver (unknown / non-Map value reaching the impl): a
-    // definite undefined would be a false claim and poison downstream
-    // guards (hoek isDeepEqual's `ref.name` path) into error-severity
-    // misses. Unknown keeps it honest.
-    return T.unknown;
-  },
-  set: (key: TypeValue, value: TypeValue, map?: TypeValue) => {
-    if (map) {
-      const typeArgs = (map as any)._typeArgs || { K: T.unknown, V: T.unknown };
-      (map as any)._typeArgs = {
-        K: typeArgs.K.kind === "unknown" ? key : simplifyUnion([typeArgs.K, key]),
-        V: typeArgs.V.kind === "unknown" ? value : simplifyUnion([typeArgs.V, value]),
-      };
-      if (entryKeyTrackable(key)) {
-        // An exact entry list can start on the first trackable set()
-        // (nothing untracked came before); once partial it stays partial.
-        if ((map as any)._entries === undefined && (map as any)._entriesExact !== false) {
-          (map as any)._entries = [];
-          (map as any)._entriesExact = true;
-        }
-        if ((map as any)._entriesExact) {
-          const entries = (map as any)._entries as MapEntry[];
-          const hit = entries.find((e) => typeValueEquals(e.key, key));
-          if (hit) hit.value = value;
-          else entries.push({ key, value });
-        }
-      } else {
-        (map as any)._entriesExact = false;
-      }
-    }
-    return map ?? T.unknown;
-  },
-  has: (key: TypeValue, map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries && entryKeyTrackable(key)) {
-      return T.literal(entries.some((e) => typeValueEquals(e.key, key)));
-    }
-    return T.boolean;
-  },
-  delete: (key: TypeValue, map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries && entryKeyTrackable(key)) {
-      const idx = entries.findIndex((e) => typeValueEquals(e.key, key));
-      if (idx >= 0) {
-        entries.splice(idx, 1);
-        return T.literal(true);
-      }
-      return T.literal(false);
-    }
-    return T.boolean;
-  },
-  clear: (value?: TypeValue, map?: TypeValue) => {
-    // m.clear() arrives as clear(receiver): the map sits in the first
-    // param slot when the call has no arguments.
-    const target = map ?? value;
-    if (target && (target as any)._entriesExact) {
-      (target as any)._entries = [];
-    }
-    return T.undefined;
-  },
-  forEach: () => T.undefined,
-  keys: (map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries) return T.tuple(entries.map((e) => e.key));
-    const typeArgs = (map as any)?._typeArgs;
-    if (typeArgs?.K) return T.array(typeArgs.K);
-    return T.array(T.unknown);
-  },
-  values: (map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries) return T.tuple(entries.map((e) => e.value));
-    const typeArgs = (map as any)?._typeArgs;
-    if (typeArgs?.V) return T.array(typeArgs.V);
-    return T.array(T.unknown);
-  },
-  entries: (map?: TypeValue) => mapEntriesIterable(map),
-};
-
-// Exact entry side table: present only when every key seen so far
-// (construction pairs + set() calls) was trackable. Partial tables must
-// not decide get()/has()/delete()/iteration — an untracked key could map
-// to anything.
-export function exactMapEntries(map: TypeValue | undefined): MapEntry[] | undefined {
-  if (!map || (map as any)._entriesExact !== true) return undefined;
-  return (map as any)._entries as MapEntry[] | undefined;
-}
-
-// entries() keeps feeding for-of destructuring (`for (const [k, v] of m)`)
-// and `new Map(...)` consumers: a tuple of [key, value] pairs when the
-// side table is complete, else Array<[K, V]>.
-export function mapEntriesIterable(map: TypeValue | undefined): TypeValue {
-  const entries = exactMapEntries(map);
-  if (entries) return T.tuple(entries.map((e) => T.tuple([e.key, e.value])));
-  const typeArgs = (map as any)?._typeArgs;
-  if (typeArgs?.K && typeArgs?.V) return T.array(T.tuple([typeArgs.K, typeArgs.V]));
-  return T.array(T.tuple([T.unknown, T.unknown]));
-}
-
-export function createMapType(args?: TypeValue[]): TypeValue {
-  const obj = T.instanceOf("Map", {});
-
-  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];
-      const keys: TypeValue[] = [];
-      const values: TypeValue[] = [];
-      const entries: MapEntry[] = [];
-      let exact = true;
-      for (const el of elements) {
-        if (el.kind === "tuple" && el.elements.length >= 2) {
-          keys.push(el.elements[0]);
-          values.push(el.elements[1]);
-          if (entryKeyTrackable(el.elements[0])) {
-            entries.push({ key: el.elements[0], value: el.elements[1] });
-          } else {
-            exact = false;
-          }
-        }
-      }
-      if (keys.length > 0) {
-        (obj as any)._typeArgs = { K: simplifyUnion(keys), V: simplifyUnion(values) };
-      }
-      // Only a fully trackable key list is exact: symbolic keys mean the
-      // recorded entries are a subset of the real ones.
-      if (exact && entries.length > 0) {
-        (obj as any)._entries = entries;
-        (obj as any)._entriesExact = true;
-      } else if (!exact) {
-        (obj as any)._entriesExact = false;
-      }
-    }
-  }
-
-  if (!(obj as any)._typeArgs) {
-    (obj as any)._typeArgs = { K: T.unknown, V: T.unknown };
-  }
-
-  return obj;
-}

package/src/builtins/builtin-promise.ts

@@ -1,116 +0,0 @@
-import { type TypeValue, T, simplifyUnion } from "@nudojs/core";
-
-export const PROMISE_STATIC_METHODS: Record<string, TypeValue> = {
-  resolve: T.unknown,
-  reject: T.never,
-  all: T.unknown,
-  race: T.unknown,
-  allSettled: T.unknown,
-  any: T.unknown,
-};
-
-export function evaluatePromiseStaticMethod(
-  methodName: string,
-  args: TypeValue[],
-): TypeValue | null {
-  if (methodName === "resolve") {
-    if (args.length > 0) return T.promise(args[0]);
-    return T.promise(T.undefined);
-  }
-
-  if (methodName === "reject") {
-    return T.promise(T.never);
-  }
-
-  if (methodName === "all") {
-    if (args.length > 0 && args[0].kind === "tuple") {
-      const elemTypes = args[0].elements.map((e: TypeValue) => {
-        if (e.kind === "promise") return e.value;
-        return T.unknown;
-      });
-      return T.promise(T.tuple(elemTypes));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      return T.promise(T.array(args[0].element));
-    }
-    return T.promise(T.array(T.unknown));
-  }
-
-  if (methodName === "race") {
-    if (args.length > 0 && args[0].kind === "tuple") {
-      const elemTypes = args[0].elements.map((e: TypeValue) => {
-        if (e.kind === "promise") return e.value;
-        return T.unknown;
-      });
-      return T.promise(simplifyUnion(elemTypes));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      const el = args[0].element;
-      return T.promise(el.kind === "promise" ? el.value : T.unknown);
-    }
-    return T.promise(T.unknown);
-  }
-
-  if (methodName === "allSettled") {
-    // Best effort: each slot settles to { status, value } — the fulfilled
-    // value is the element's promise payload (unknown for non-promises).
-    const settledOf = (e: TypeValue): TypeValue =>
-      T.object({
-        status: T.union(T.literal("fulfilled"), T.literal("rejected")),
-        value: e.kind === "promise" ? e.value : T.unknown,
-      });
-    if (args.length > 0 && args[0].kind === "tuple") {
-      return T.promise(T.tuple(args[0].elements.map(settledOf)));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      return T.promise(T.array(settledOf(args[0].element)));
-    }
-    return T.promise(T.array(T.unknown));
-  }
-
-  if (methodName === "any") {
-    if (args.length > 0 && args[0].kind === "tuple") {
-      const elemTypes = args[0].elements.map((e: TypeValue) => {
-        if (e.kind === "promise") return e.value;
-        return T.unknown;
-      });
-      return T.promise(simplifyUnion(elemTypes));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      const el = args[0].element;
-      return T.promise(el.kind === "promise" ? el.value : T.unknown);
-    }
-    return T.promise(T.unknown);
-  }
-
-  return null;
-}
-
-export function evaluatePromiseInstanceMethod(
-  promiseValue: TypeValue,
-  methodName: string,
-  args: TypeValue[],
-): TypeValue | null {
-  if (methodName === "then") {
-    if (promiseValue.kind === "promise") {
-      // A real function callback is executed by the evaluator's main call
-      // path (applyPromiseThenCallback) before reaching here; only
-      // non-callable handlers fall through to an unresolved value type.
-      return T.promise(T.unknown);
-    }
-  }
-
-  if (methodName === "catch") {
-    if (promiseValue.kind === "promise") {
-      return promiseValue; // catch returns same promise type
-    }
-  }
-
-  if (methodName === "finally") {
-    if (promiseValue.kind === "promise") {
-      return promiseValue; // finally returns same promise type
-    }
-  }
-
-  return null;
-}