@nudojs/core 0.2.0 → 0.3.0

package/src/algebra/constraint.ts

@@ -0,0 +1,304 @@
+/**
+ * 约束模板构建器（参数无关）。
+ *
+ *   number().gt(0)                    → 占位项 self 上的 Pred
+ *   number().int().ge(0)              → 整数 + 下界
+ *   string().min(1)                   → 非空串（长度）
+ *   array(number().gt(0))             → 元素约束
+ *   shape({ id: number().gt(0) })     → object 形状约束
+ *   instantiate("ms")                 → Pred ms > 0 / u.id > 0 ∧ …
+ *
+ * 在 *.nudo.js 里执行；不是 zod 绑定，是我们自己的运行时 API。
+ * 不需要 interface/type 语法——契约用 JS 表达式声明。
+ */
+
+import type { Pred, PrimName } from "./pred.ts";
+import { and, gt, ge, lt, le, ptypeof } from "./pred.ts";
+import { v as termVar, lit, app as termApp, type Term } from "./term.ts";
+import type { Abs } from "./abs.ts";
+import { abs } from "./abs.ts";
+
+/** 模板占位项；instantiate 时换成真实参数名 */
+export const SELF = "__nudo_self__";
+
+function selfTerm(): Term {
+  return termVar(SELF);
+}
+
+/** 字段访问项：u.id */
+export function getTerm(obj: Term, key: string): Term {
+  return termApp("get", [obj, lit(key)]);
+}
+
+/** 长度项：length(u) */
+export function lenTerm(t: Term): Term {
+  return termApp("length", [t]);
+}
+
+export type NudoField = {
+  constraint: NudoConstraint;
+  optional?: boolean;
+};
+
+export type NudoConstraint = {
+  readonly __nudoConstraint: true;
+  readonly prim?: PrimName;
+  readonly preds: Pred[];
+  /** object 形状：字段名 → 嵌套约束 */
+  readonly fields?: Record<string, NudoField>;
+  /** array 元素约束 */
+  readonly element?: NudoConstraint;
+  /** 整数（number 链式 .int()） */
+  readonly int?: boolean;
+  /** 该约束整体可选（shape 字段用；不用 optional 以免与链式方法撞名） */
+  readonly isOptional?: boolean;
+};
+
+function isConstraint(x: unknown): x is NudoConstraint {
+  return (
+    !!x &&
+    typeof x === "object" &&
+    (x as NudoConstraint).__nudoConstraint === true
+  );
+}
+
+export function isNudoConstraint(x: unknown): x is NudoConstraint {
+  return isConstraint(x);
+}
+
+/** 链式约束：不可变，每次 .gt() 返回新对象 */
+export type ConstraintBuilder = NudoConstraint & {
+  gt(n: number): ConstraintBuilder;
+  ge(n: number): ConstraintBuilder;
+  lt(n: number): ConstraintBuilder;
+  le(n: number): ConstraintBuilder;
+  /** number：要求整数 */
+  int(): ConstraintBuilder;
+  /** string：长度下界 */
+  min(n: number): ConstraintBuilder;
+  /** string：长度上界 */
+  max(n: number): ConstraintBuilder;
+  /** string：精确长度 */
+  length(n: number): ConstraintBuilder;
+  /** 字段可选（仅在 shape 内有意义） */
+  optional(): ConstraintBuilder;
+};
+
+function makeBuilder(
+  prim: PrimName | undefined,
+  preds: Pred[],
+  extra?: {
+    fields?: Record<string, NudoField>;
+    element?: NudoConstraint;
+    int?: boolean;
+    optional?: boolean;
+  },
+): ConstraintBuilder {
+  const fields = extra?.fields;
+  const element = extra?.element;
+  const isInt = extra?.int;
+  const optional = extra?.optional;
+  const base: NudoConstraint = {
+    __nudoConstraint: true,
+    ...(prim ? { prim } : {}),
+    preds: [...preds],
+    ...(fields ? { fields } : {}),
+    ...(element ? { element } : {}),
+    ...(isInt ? { int: true } : {}),
+    ...(optional ? { isOptional: true } : {}),
+  };
+  const add = (p: Pred): ConstraintBuilder =>
+    makeBuilder(prim, [...preds, p], extra);
+  return Object.assign(Object.create(null), base, {
+    gt: (n: number) => add(gt(selfTerm(), lit(n))),
+    ge: (n: number) => add(ge(selfTerm(), lit(n))),
+    lt: (n: number) => add(lt(selfTerm(), lit(n))),
+    le: (n: number) => add(le(selfTerm(), lit(n))),
+    int: () => makeBuilder(prim ?? "number", preds, { ...extra, int: true }),
+    min: (n: number) => add(ge(lenTerm(selfTerm()), lit(n))),
+    max: (n: number) => add(le(lenTerm(selfTerm()), lit(n))),
+    length: (n: number) =>
+      add(and(ge(lenTerm(selfTerm()), lit(n)), le(lenTerm(selfTerm()), lit(n)))),
+    optional: () => makeBuilder(prim, preds, { ...extra, optional: true }),
+  }) as ConstraintBuilder;
+}
+
+/** number() —— 约束 number 原语 + 后续链式界 */
+export function number(): ConstraintBuilder {
+  return makeBuilder("number", []);
+}
+
+export function string(): ConstraintBuilder {
+  return makeBuilder("string", []);
+}
+
+export function boolean(): ConstraintBuilder {
+  return makeBuilder("boolean", []);
+}
+
+/** array(item) —— 数组，元素满足 item */
+export function array(item: NudoConstraint | ConstraintBuilder): ConstraintBuilder {
+  if (!isConstraint(item)) return makeBuilder(undefined, []);
+  return makeBuilder(undefined, [], { element: item });
+}
+
+/**
+ * object 形状约束（契约规范形状，无需 interface）：
+ *
+ *   shape({ id: number().gt(0), name: string() })
+ */
+export function shape(
+  fields: Record<string, NudoConstraint | ConstraintBuilder>,
+): ConstraintBuilder {
+  const mapped: Record<string, NudoField> = {};
+  for (const [k, v] of Object.entries(fields)) {
+    if (!isConstraint(v)) continue;
+    mapped[k] = {
+      constraint: v,
+      ...(v.isOptional ? { optional: true } : {}),
+    };
+  }
+  return makeBuilder(undefined, [], { fields: mapped });
+}
+
+function substTerm(t: Term, paramName: string): Term {
+  if (t.op === "var" && t.id === SELF) return termVar(paramName);
+  if (t.op === "app" && t.fn === "get" && t.args.length === 2) {
+    return getTerm(substTerm(t.args[0]!, paramName), String(
+      t.args[1]!.op === "lit" ? t.args[1]!.value : "",
+    ));
+  }
+  return t;
+}
+
+function substPred(p: Pred, paramName: string): Pred {
+  switch (p.op) {
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+    case "eq":
+    case "ne": {
+      return { op: p.op, a: substTerm(p.a, paramName), b: substTerm(p.b, paramName) };
+    }
+    case "typeof": {
+      return { op: "typeof", t: substTerm(p.t, paramName), type: p.type };
+    }
+    case "and":
+      return and(...p.args.map((x) => substPred(x, paramName)));
+    default:
+      return p;
+  }
+}
+
+/** 把模板绑定到参数名：self → paramName；shape 展开为字段访问 Pred */
+export function instantiateConstraint(
+  c: NudoConstraint,
+  paramName: string,
+): Pred {
+  // shape：展开为 and(字段 preds)
+  if (c.fields) {
+    const parts: Pred[] = [];
+    for (const [key, field] of Object.entries(c.fields)) {
+      const fieldTerm = getTerm(termVar(paramName), key);
+      parts.push(instantiateOnTerm(field.constraint, fieldTerm));
+    }
+    if (c.prim) parts.push(ptypeof(termVar(paramName), c.prim));
+    if (parts.length === 0) return { op: "true" };
+    return parts.length === 1 ? parts[0]! : and(...parts);
+  }
+
+  const preds = c.preds.map((p) => substPred(p, paramName));
+  // prim 可作为 typeof 约束补上（optional）
+  if (c.prim && c.preds.length === 0) {
+    return ptypeof(termVar(paramName), c.prim);
+  }
+  return preds.length === 0 ? { op: "true" } : preds.length === 1 ? preds[0]! : and(...preds);
+}
+
+/** 在给定项上实例化约束（shape 字段递归用） */
+function instantiateOnTerm(c: NudoConstraint, t: Term): Pred {
+  if (c.fields) {
+    const parts: Pred[] = [];
+    for (const [key, field] of Object.entries(c.fields)) {
+      parts.push(instantiateOnTerm(field.constraint, getTerm(t, key)));
+    }
+    if (parts.length === 0) return { op: "true" };
+    return parts.length === 1 ? parts[0]! : and(...parts);
+  }
+  const subst = (p: Pred): Pred => {
+    switch (p.op) {
+      case "gt":
+      case "ge":
+      case "lt":
+      case "le":
+      case "eq":
+      case "ne": {
+        const a = p.a.op === "var" && p.a.id === SELF ? t : p.a;
+        const b = p.b.op === "var" && p.b.id === SELF ? t : p.b;
+        return { op: p.op, a, b };
+      }
+      case "typeof": {
+        const tt = p.t.op === "var" && p.t.id === SELF ? t : p.t;
+        return { op: "typeof", t: tt, type: p.type };
+      }
+      case "and":
+        return and(...p.args.map(subst));
+      default:
+        return p;
+    }
+  };
+  const preds = c.preds.map(subst);
+  if (c.prim && c.preds.length === 0) return ptypeof(t, c.prim);
+  return preds.length === 0 ? { op: "true" } : preds.length === 1 ? preds[0]! : and(...preds);
+}
+
+/**
+ * 契约 → 函数入口 param Abs（infer/hover 用）。
+ * 标量：prim + pred；shape：obj slots 递归。
+ */
+export function constraintToEntryAbs(
+  c: NudoConstraint,
+  paramName: string,
+): Abs {
+  const t = termVar(paramName);
+  if (c.fields) {
+    const slots: Record<string, { value: Abs; optional?: boolean }> = {};
+    for (const [key, field] of Object.entries(c.fields)) {
+      const fieldTerm = getTerm(t, key);
+      slots[key] = {
+        value: constraintOnTermAbs(field.constraint, fieldTerm),
+        ...(field.optional || field.constraint.isOptional
+          ? { optional: true }
+          : {}),
+      };
+    }
+    return abs({ k: "obj", slots }, t, undefined, "path");
+  }
+  return constraintOnTermAbs(c, t);
+}
+
+function constraintOnTermAbs(c: NudoConstraint, t: Term): Abs {
+  if (c.fields) {
+    const slots: Record<string, { value: Abs; optional?: boolean }> = {};
+    for (const [key, field] of Object.entries(c.fields)) {
+      slots[key] = {
+        value: constraintOnTermAbs(field.constraint, getTerm(t, key)),
+        ...(field.optional || field.constraint.isOptional
+          ? { optional: true }
+          : {}),
+      };
+    }
+    return abs({ k: "obj", slots }, t, undefined, "path");
+  }
+  const pred = instantiateOnTerm(c, t);
+  const predOut = pred.op === "true" ? undefined : pred;
+  if (c.prim) {
+    return abs({ k: "prim", type: c.prim }, t, predOut, "path");
+  }
+  // 有界但无 prim：按 number 处理（number().gt(0) 已带 prim）
+  if (c.preds.length > 0) {
+    return abs({ k: "prim", type: "number" }, t, predOut, "path");
+  }
+  return abs({ k: "any" }, t, undefined, "path");
+}

package/src/algebra/denote.ts

@@ -0,0 +1,166 @@
+/**
+ * 指称：Abs → 运行时谓词（设计 §2.7）。
+ * - 无 pred：按 shape 检查（typeof / 结构）
+ * - 有 pred：在 `term ↦ v` 下检查可判定的数值比较
+ * - sum：任一成员
+ */
+
+import type { Abs, Shape } from "./abs.ts";
+import { litValue } from "./abs.ts";
+import type { Pred } from "./pred.ts";
+
+/** Abs 上的运行时守卫表达式（JS boolean 布尔串） */
+export function denoteGuard(a: Abs, v: string): string {
+  // 字面量：等值已蕴含 typeof，短路
+  const lv = litValue(a);
+  if (lv !== undefined && (!a.pred || a.pred.op === "true")) {
+    return `${v} === ${JSON.stringify(lv)}`;
+  }
+  const shape = denoteShape(a.shape, v);
+  const pred = denotePred(a, v);
+  if (shape === "true") return pred;
+  if (pred === "true") return shape;
+  return `(${shape}) && (${pred})`;
+}
+
+function denoteShape(s: Shape, v: string): string {
+  switch (s.k) {
+    case "never":
+      return "false";
+    case "unknown":
+    case "any":
+      return "true";
+    case "prim":
+      switch (s.type) {
+        case "number":
+          return `typeof ${v} === "number"`;
+        case "string":
+          return `typeof ${v} === "string"`;
+        case "boolean":
+          return `typeof ${v} === "boolean"`;
+        case "bigint":
+          return `typeof ${v} === "bigint"`;
+        case "symbol":
+          return `typeof ${v} === "symbol"`;
+        default:
+          return "true";
+      }
+    case "obj": {
+      const checks = [`typeof ${v} === "object"`, `${v} !== null`];
+      for (const [key, slot] of Object.entries(s.slots)) {
+        const access = `${v}.${key}`;
+        const inner = denoteGuard(slot.value, access);
+        if (slot.optional) {
+          if (inner !== "true") checks.push(`(${access} === undefined || ${inner})`);
+        } else {
+          if (inner !== "true") checks.push(inner);
+        }
+      }
+      return checks.join(" && ");
+    }
+    case "arr":
+      return `Array.isArray(${v}) && ${v}.every((item) => ${denoteGuard(s.element, "item")})`;
+    case "tuple": {
+      const checks = [`Array.isArray(${v})`];
+      const minLen = s.elements.length;
+      checks.push(s.rest ? `${v}.length >= ${minLen}` : `${v}.length === ${minLen}`);
+      s.elements.forEach((el, i) => {
+        const inner = denoteGuard(el, `${v}[${i}]`);
+        if (inner !== "true") checks.push(inner);
+      });
+      if (s.rest) {
+        // rest 槽：长度超出部分统一检查
+        const rest = denoteGuard(s.rest, "item");
+        if (rest !== "true") {
+          checks.push(`${v}.slice(${minLen}).every((item) => ${rest})`);
+        }
+      }
+      return checks.join(" && ");
+    }
+    case "fn":
+      return `typeof ${v} === "function"`;
+    case "eff":
+      if (s.eff === "promise") return `${v} instanceof Promise`;
+      return "true";
+    case "brand":
+      return denoteShape(s.shape.shape, v);
+    case "sum": {
+      if (s.members.length === 0) return "false";
+      const parts = s.members.map((m) => denoteGuard(m, v));
+      return `(${parts.join(" || ")})`;
+    }
+  }
+}
+
+/**
+ * 在 `term ↦ v` 下检查 pred。
+ * 仅编码可判定的数值比较与字面量等值；不可判定返回 "true"（保守、不撒谎）。
+ */
+function denotePred(a: Abs, v: string): string {
+  const p = a.pred;
+  if (!p || p.op === "true") {
+    // 无 pred：字面量 term 直接等值
+    const lv = litValue(a);
+    if (lv !== undefined) return `${v} === ${JSON.stringify(lv)}`;
+    return "true";
+  }
+  return predAsJs(p, v, a);
+}
+
+function predAsJs(p: Pred, v: string, a: Abs): string {
+  switch (p.op) {
+    case "true":
+      return "true";
+    case "false":
+      return "false";
+    case "and":
+      return p.args.map((x) => predAsJs(x, v, a)).join(" && ");
+    case "or":
+      return `(${p.args.map((x) => predAsJs(x, v, a)).join(" || ")})`;
+    case "not": {
+      const inner = predAsJs(p.arg, v, a);
+      return inner === "true" ? "false" : `!(${inner})`;
+    }
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+    case "eq":
+    case "ne": {
+      // 仅支持 term 侧为值本身（var/lit 与 Abs.term 一致）或字面量比较
+      const op = { gt: ">", ge: ">=", lt: "<", le: "<=", eq: "===", ne: "!==" }[p.op];
+      const leftIsValue = termIsValue(p.a, a);
+      const rightLit = litOfTerm(p.b);
+      if (leftIsValue && rightLit !== undefined) {
+        return `${v} ${op} ${JSON.stringify(rightLit)}`;
+      }
+      const leftLit = litOfTerm(p.a);
+      const rightIsValue = termIsValue(p.b, a);
+      if (rightIsValue && leftLit !== undefined) {
+        return `${JSON.stringify(leftLit)} ${op} ${v}`;
+      }
+      // 双字面量：可判定
+      if (leftLit !== undefined && rightLit !== undefined) {
+        return `${JSON.stringify(leftLit)} ${op} ${JSON.stringify(rightLit)}`;
+      }
+      return "true";
+    }
+    default:
+      return "true";
+  }
+}
+
+function litOfTerm(t: import("./term.ts").Term): unknown {
+  return t.op === "lit" ? t.value : undefined;
+}
+
+/** term 是否可视为「当前检查值 v」本身 */
+function termIsValue(t: import("./term.ts").Term, a: Abs): boolean {
+  if (t.op === "var") return true;
+  if (t.op === "lit") {
+    const lv = litValue(a);
+    return lv !== undefined && Object.is(lv, t.value);
+  }
+  // app 等复合项：保守不绑到 v
+  return false;
+}

package/src/algebra/diagnostics.ts

@@ -0,0 +1,210 @@
+/**
+ * 约束诊断：检查调用点实参是否满足函数的前置约束 / 参数 shape。
+ * 输出可行动的建议，而不是 TS 式「类型不匹配」。
+ */
+
+import type { Abs } from "./abs.ts";
+import { litValue } from "./abs.ts";
+import type { Pred, Phi } from "./pred.ts";
+import { implies, predToString, pTrue, gt, ge, lt, le } from "./pred.ts";
+import type { Term } from "./term.ts";
+import { termToString, v as termVar, lit } from "./term.ts";
+import { generalizeFromAst, type PolyFn } from "./generalize.ts";
+import { analyzeFn } from "./ast-eval.ts";
+import { formatShape } from "./format.ts";
+
+export type Diagnostic = {
+  severity: "error" | "warning" | "info";
+  code: string;
+  message: string;
+  suggestion?: string;
+  fn?: string;
+  argIndex?: number;
+};
+
+/**
+ * 检查实参是否满足「期望约束」。
+ * expect: 相对参数 term 的 pred，例如 term > 0
+ * arg: 实际实参 Abs
+ */
+export function checkArg(
+  arg: Abs,
+  expect: Pred | undefined,
+  phi: Phi = pTrue,
+): Diagnostic | undefined {
+  if (!expect || expect.op === "true") return undefined;
+  if (arg.shape.k === "unknown" && !arg.term) {
+    return {
+      severity: "warning",
+      code: "nudo:arg-opaque",
+      message: `实参类型 unknown，无法验证约束 ${predToString(expect)}`,
+      suggestion: "补充调用点、@nudo:case，或 --assume 提供前置条件",
+    };
+  }
+  // 若 Φ 与实参自身 pred 已蕴含 expect → OK
+  const combined: Phi =
+    arg.pred && arg.pred.op !== "true"
+      ? phi.op === "true"
+        ? arg.pred
+        : { op: "and", args: [phi, arg.pred] }
+      : phi;
+  if (implies(combined, expect)) return undefined;
+
+  // 字面量直接判定
+  const lv = litValue(arg);
+  if (
+    lv !== undefined &&
+    (expect.op === "gt" || expect.op === "ge" || expect.op === "lt" || expect.op === "le")
+  ) {
+    const ok = decideLitCmp(lv, expect);
+    if (ok === true) return undefined;
+    if (ok === false) {
+      return {
+        severity: "error",
+        code: "nudo:constraint-violated",
+        message: `实参 ${JSON.stringify(lv)} 不满足 ${predToString(expect)}`,
+        suggestion: `改用满足约束的值，或放宽函数前置条件`,
+      };
+    }
+  }
+
+  return {
+    severity: "warning",
+    code: "nudo:constraint-unproven",
+    message: `无法证明实参满足 ${predToString(expect)}`,
+    suggestion: `已知信息不足；可 --assume 或补 case`,
+  };
+}
+
+function decideLitCmp(
+  lv: string | number | boolean | null | undefined,
+  p: Extract<Pred, { op: "gt" | "ge" | "lt" | "le" }>,
+): boolean | undefined {
+  if (typeof lv !== "number" || p.b.op !== "lit" || typeof p.b.value !== "number") {
+    return undefined;
+  }
+  const n = p.b.value;
+  switch (p.op) {
+    case "gt":
+      return lv > n;
+    case "ge":
+      return lv >= n;
+    case "lt":
+      return lv < n;
+    case "le":
+      return lv <= n;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * 对一次函数调用做诊断：实参 shape + 约束。
+ */
+export function checkCall(
+  source: string,
+  fnName: string,
+  args: Abs[],
+  phi: Phi = pTrue,
+): Diagnostic[] {
+  const diags: Diagnostic[] = [];
+  const g = generalizeFromAst(fnName, source);
+  if (!g) {
+    diags.push({
+      severity: "error",
+      code: "nudo:fn-not-found",
+      message: `未找到函数 ${fnName}`,
+    });
+    return diags;
+  }
+
+  // 参数个数
+  if (args.length !== g.params.length) {
+    diags.push({
+      severity: "error",
+      code: "nudo:arg-count",
+      message: `${fnName} 期望 ${g.params.length} 个参数，实际 ${args.length}`,
+      fn: fnName,
+    });
+    return diags;
+  }
+
+  // 从符号执行结果提取「对参数的隐含要求」：
+  // 若 symbolic.pred 形如 (A1 > 0)，则要求对应实参满足
+  const required = extractParamRequirements(g);
+  args.forEach((arg, i) => {
+    const req = required.get(i);
+    const d = checkArg(arg, req, phi);
+    if (d) diags.push({ ...d, fn: fnName, argIndex: i });
+  });
+
+  // 尝试实际求值，捕获 partial 结果
+  try {
+    const result = analyzeFn(source, fnName, args, phi);
+    if (result.conf === "partial" || result.conf === "opaque") {
+      diags.push({
+        severity: "info",
+        code: "nudo:partial-result",
+        message: `${fnName}(...) 结果置信度 ${result.conf}`,
+        suggestion: "补充调用点或约束可提高精度",
+        fn: fnName,
+      });
+    }
+  } catch (e) {
+    diags.push({
+      severity: "error",
+      code: "nudo:eval-error",
+      message: `求值失败: ${(e as Error).message}`,
+      fn: fnName,
+    });
+  }
+
+  return diags;
+}
+
+/**
+ * 从 generalize 的 symbolic.pred 提取对每个参数位置的要求。
+ * 例如 scale 的 pred 若是 (A1+1)>1，则不直接是 A1 的约束；
+ * 若 pred 是 A1>0，则要求实参 >0。
+ * Phase C 简化：只识别 pred 中直接比较 type-param 的形式。
+ */
+function extractParamRequirements(g: PolyFn): Map<number, Pred> {
+  const map = new Map<number, Pred>();
+  const pred = g.symbolic.pred;
+  if (!pred || pred.op === "true") return map;
+
+  const paramIndex = new Map<string, number>();
+  g.typeParams.forEach((t, i) => paramIndex.set(t.id, i));
+
+  const consider = (p: Pred): void => {
+    if (p.op === "and") {
+      p.args.forEach(consider);
+      return;
+    }
+    if (
+      (p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") &&
+      p.a.op === "var" &&
+      paramIndex.has(p.a.id) &&
+      p.b.op === "lit"
+    ) {
+      // 把 A1 换成 term 占位 —— checkArg 时用实参 term 比较
+      // 这里存的是「相对 type-param」的 pred；checkArg 期望的是相对实参 term
+      // 简化：存为对参数位置的数值界
+      map.set(paramIndex.get(p.a.id)!, p as Pred);
+    }
+  };
+  consider(pred);
+  return map;
+}
+
+export function formatDiagnostics(diags: Diagnostic[]): string {
+  if (diags.length === 0) return "No issues found.";
+  return diags
+    .map((d) => {
+      const loc = d.fn ? `${d.fn}${d.argIndex !== undefined ? `[${d.argIndex}]` : ""}: ` : "";
+      let s = `[${d.severity}] ${loc}${d.message} (${d.code})`;
+      if (d.suggestion) s += `\n    → ${d.suggestion}`;
+      return s;
+    })
+    .join("\n");
+}

package/src/algebra/exec/call.ts

@@ -0,0 +1,29 @@
+/**
+ * 调用 Abs 一等函数（absFunction impl）或 mock apply。
+ * 供 B 路径 import 绑定包装：`(...args) => $call(absFn, args)`。
+ */
+
+import type { Abs } from "../abs.ts";
+import { abs, unknown } from "../abs.ts";
+import { getFnImpl } from "../abs-fn.ts";
+import { evalNode, emptyEnv, type AstEnv } from "../ast-eval.ts";
+import { defaultLeakBudget } from "../leak.ts";
+import { pTrue } from "../pred.ts";
+
+export function $call(fn: Abs, args: Abs[]): Abs {
+  const impl = getFnImpl(fn);
+  if (!impl) {
+    if (fn?.shape?.k === "fn") return unknown;
+    return unknown;
+  }
+  if (impl.apply) return impl.apply(args);
+  const base = impl.env ?? emptyEnv();
+  let local: AstEnv = { vars: new Map(base.vars), fns: base.fns };
+  if (base.classes) local = { ...local, classes: base.classes };
+  impl.params.forEach((p, i) => {
+    local.vars.set(p, args[i] ?? unknown);
+  });
+  const r = evalNode(impl.body, local, pTrue, defaultLeakBudget);
+  if (r.threw) return abs({ k: "never" }, undefined, undefined, "exact");
+  return r.value;
+}