@nudojs/core 0.3.0 → 0.4.0

package/src/algebra/__tests__/abs-native.test.ts

@@ -1,176 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { analyzeFn, evalSource } from "../ast-eval.ts";
-import { abs, num, numLit, unknown } from "../abs.ts";
-import { v, lit } from "../term.ts";
-import { gt, pTrue } from "../pred.ts";
-import { typeValueToString } from "../../type-value.ts";
-import { absToTypeValue } from "../bridge.ts";
-import { formatAbs } from "../format.ts";
-
-function show(a: ReturnType<typeof analyzeFn>): string {
-  return typeValueToString(absToTypeValue(a));
-}
-
-describe("abs-native ast-eval", () => {
-  it("literal arith", () => {
-    const r = analyzeFn(`function f(){ return 1+2*3; }`, "f", []);
-    expect(show(r)).toBe("7");
-  });
-
-  it("param + 1 with constraint via phi in source", () => {
-    const src = `
-      function f(x) {
-        if (x > 0) return x + 1;
-        return 0;
-      }
-    `;
-    const r = analyzeFn(src, "f", [abs(num().shape, v("x"), gt(v("x"), lit(0)), "path")]);
-    // x>0 时 x+1 应带约束
-    expect(r.shape.k === "prim" || r.shape.k === "sum").toBe(true);
-  });
-
-  it("logical && short-circuit", () => {
-    const r = analyzeFn(`function f(){ return false && 1; }`, "f", []);
-    expect(show(r)).toBe("false");
-  });
-
-  it("typeof", () => {
-    const r = analyzeFn(`function f(){ return typeof 1; }`, "f", []);
-    expect(show(r)).toBe('"number"');
-  });
-
-  it("template literal", () => {
-    const r = analyzeFn(`function f(x){ return \`n=\${x}\`; }`, "f", [numLit(3)]);
-    expect(show(r)).toBe('"n=3"');
-  });
-
-  it("first-class arrow", () => {
-    const src = `
-      function f() {
-        const add = (a, b) => a + b;
-        return add(2, 3);
-      }
-    `;
-    const r = analyzeFn(src, "f", []);
-    expect(show(r)).toBe("5");
-  });
-
-  it("div and mod", () => {
-    expect(show(analyzeFn(`function f(){ return 10/2; }`, "f", []))).toBe("5");
-    expect(show(analyzeFn(`function f(){ return 10%3; }`, "f", []))).toBe("1");
-  });
-
-  it("nullish === decided", () => {
-    const r = analyzeFn(`function f(x){ return x === null; }`, "f", [numLit(1)]);
-    expect(show(r)).toBe("false");
-  });
-
-  it("for loop runs with update", () => {
-    const src = `
-      function f() {
-        let s = 0;
-        for (let i = 0; i < 3; i++) s = s + i;
-        return s;
-      }
-    `;
-    const r = analyzeFn(src, "f", []);
-    expect(r.shape.k === "prim" || r.shape.k === "unknown").toBe(true);
-  });
-
-  it("for-of over tuple", () => {
-    const src = `
-      function f(xs) {
-        let s = 0;
-        for (const x of xs) s = s + x;
-        return s;
-      }
-    `;
-    const tup = abs({ k: "tuple", elements: [numLit(1), numLit(2)] }, undefined, undefined, "exact");
-    const r = analyzeFn(src, "f", [tup]);
-    expect(r.shape.k === "prim" || r.shape.k === "unknown").toBe(true);
-  });
-
-  it("while with break", () => {
-    const src = `
-      function f() {
-        let i = 0;
-        while (true) {
-          i = i + 1;
-          if (i > 2) break;
-        }
-        return i;
-      }
-    `;
-    const r = analyzeFn(src, "f", []);
-    expect(r.shape.k === "prim" || r.shape.k === "unknown").toBe(true);
-  });
-
-  it("try/catch binds thrown value", () => {
-    const src = `
-      function f() {
-        try {
-          throw 1;
-        } catch (e) {
-          return e;
-        }
-      }
-    `;
-    const r = analyzeFn(src, "f", []);
-    expect(show(r)).toBe("1");
-  });
-
-  it("string methods fold", () => {
-    expect(show(analyzeFn(`function f(){ return "abc".startsWith("a"); }`, "f", []))).toBe("true");
-    expect(show(analyzeFn(`function f(){ return "abc".toUpperCase(); }`, "f", []))).toBe('"ABC"');
-    expect(show(analyzeFn(`function f(){ return "hello".length; }`, "f", []))).toBe("5");
-  });
-
-  it("array join returns string", () => {
-    const r = analyzeFn(`function f(xs){ return xs.join(","); }`, "f", [
-      abs({ k: "arr", element: abs({ k: "prim", type: "string" }, undefined, undefined, "exact") }, undefined, undefined, "exact"),
-    ]);
-    expect(r.shape).toEqual({ k: "prim", type: "string" });
-  });
-
-  it("Math and global builtins on Abs", () => {
-    expect(show(analyzeFn(`function f(){ return Math.floor(3.7); }`, "f", []))).toBe("3");
-    expect(show(analyzeFn(`function f(){ return Math.max(1, 5); }`, "f", []))).toBe("5");
-    expect(show(analyzeFn(`function f(){ return Array.isArray([]); }`, "f", []))).toBe("true");
-    expect(show(analyzeFn(`function f(){ return parseInt("42"); }`, "f", []))).toBe("42");
-    expect(show(analyzeFn(`function f(){ return Number.isInteger(3); }`, "f", []))).toBe("true");
-  });
-
-  it("Object.keys of object shape", () => {
-    const src = `function f(){ return Object.keys({ a: 1, b: "x" }); }`;
-    const r = analyzeFn(src, "f", []);
-    expect(r.shape.k === "tuple" || r.shape.k === "arr").toBe(true);
-  });
-
-  it("Promise.resolve and then", () => {
-    const src = `
-      function f() {
-        return Promise.resolve(1).then((x) => x + 1);
-      }
-    `;
-    const r = analyzeFn(src, "f", []);
-    expect(r.shape.k).toBe("eff");
-  });
-
-  it("Date.now and RegExp.test", () => {
-    const n = analyzeFn(`function f(){ return Date.now(); }`, "f", []);
-    expect(n.shape.k === "prim" && (n.shape as { type: string }).type === "number").toBe(true);
-    const t = analyzeFn(`function f(){ return /a/.test("a"); }`, "f", []);
-    // 字面正则：.test 可能走 member 路径；至少 boolean 或 unknown
-    expect(t.shape.k === "prim" || t.shape.k === "unknown").toBe(true);
-  });
-
-  it("evalProgramAbs executes top-level", async () => {
-    const { evalProgramAbs } = await import("../ast-eval.ts");
-    const { env, last } = evalProgramAbs(`
-      const x = 1 + 2;
-      function inc(n) { return n + 1; }
-    `);
-    expect(env.vars.get("x")).toBeDefined();
-    expect(env.fns.has("inc")).toBe(true);
-  });
-});

package/src/algebra/__tests__/arithmetic.test.ts

@@ -1,170 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  add,
-  sub,
-  mul,
-  div,
-  mod,
-  cmp,
-  numLit,
-  numVar,
-  strLit,
-  gtNum,
-  geNum,
-  ltNum,
-  lit,
-  v,
-  termToString,
-  predToString,
-  litValue,
-  implies,
-  simplifyTerm,
-  app,
-} from "../index.ts";
-
-describe("term simplify", () => {
-  it("folds 1+3", () => {
-    expect(simplifyTerm(app("+", [lit(1), lit(3)]))).toEqual(lit(4));
-  });
-  it("x+0 = x", () => {
-    expect(simplifyTerm(app("+", [v("x"), lit(0)]))).toEqual(v("x"));
-  });
-  it("0+x = x", () => {
-    expect(simplifyTerm(app("+", [lit(0), v("x")]))).toEqual(v("x"));
-  });
-  it("x*0 = 0", () => {
-    expect(simplifyTerm(app("*", [v("x"), lit(0)]))).toEqual(lit(0));
-  });
-});
-
-describe("add monotonicity", () => {
-  it("unconstrained any + 1: number|string 并集，term kept（real JS）", () => {
-    // 无契约时 x 是 any；score('x') 合法，+ 可能是拼接也可能是加法
-    const anyA = {
-      shape: { k: "any" as const },
-      term: v("A1"),
-      conf: "path" as const,
-    };
-    const r = add(anyA, numLit(1));
-    expect(r.shape.k).toBe("sum");
-    if (r.shape.k === "sum") {
-      const kinds = r.shape.members.map((m) =>
-        m.shape.k === "prim" ? (m.shape as { type: string }).type : m.shape.k,
-      );
-      expect(kinds.sort()).toEqual(["number", "string"]);
-    }
-    expect(termToString(r.term!)).toBe("(A1 + 1)");
-  });
-
-  it("unconstrained any - * / % → number (JS ToNumber)", () => {
-    const anyA = {
-      shape: { k: "any" as const },
-      term: v("A1"),
-      conf: "path" as const,
-    };
-    const one = numLit(1);
-    for (const [name, r] of [
-      ["sub", sub(anyA, one)],
-      ["mul", mul(anyA, one)],
-      ["div", div(anyA, one)],
-      ["mod", mod(anyA, one)],
-    ] as const) {
-      expect(r.shape, name).toEqual({ k: "prim", type: "number" });
-      expect(r.term, name).toBeDefined();
-    }
-    expect(termToString(sub(anyA, one).term!)).toBe("(A1 - 1)");
-  });
-
-  it("x>0 + 1 ⇒ term>1", () => {
-    const phi = gtNum(v("x"), 0);
-    const r = add(numVar("x", gtNum(v("x"), 0)), numLit(1), phi);
-    expect(termToString(r.term!)).toBe("(x + 1)");
-    expect(r.pred!.op).toBe("gt");
-  });
-
-  it("x>2 + y>3 ⇒ (x+y)>5", () => {
-    const phi = { op: "and" as const, args: [gtNum(v("x"), 2), gtNum(v("y"), 3)] };
-    const r = add(
-      numVar("x", gtNum(v("x"), 2)),
-      numVar("y", gtNum(v("y"), 3)),
-      phi,
-    );
-    expect(r.pred!.op).toBe("gt");
-    if (r.pred!.op === "gt") {
-      expect(r.pred!.b).toEqual(lit(5));
-    }
-  });
-
-  it("x≥1 + 0 literal keeps ≥ via simplify to x", () => {
-    const phi = geNum(v("x"), 1);
-    const r = add(numVar("x", geNum(v("x"), 1)), numLit(0), phi);
-    // x+0 simplifies to x
-    expect(termToString(r.term!)).toBe("x");
-  });
-
-  it("literal 2+3 = 5 exact", () => {
-    const r = add(numLit(2), numLit(3));
-    expect(litValue(r)).toBe(5);
-    expect(r.conf).toBe("exact");
-  });
-});
-
-describe("sub / mul", () => {
-  it("5-2 = 3", () => {
-    expect(litValue(sub(numLit(5), numLit(2)))).toBe(3);
-  });
-  it("x>0 - 1 ⇒ (x-1)>-1? x>0 ⇒ x-1 > -1", () => {
-    const phi = gtNum(v("x"), 0);
-    const r = sub(numVar("x", gtNum(v("x"), 0)), numLit(1), phi);
-    expect(r.term).toBeDefined();
-    expect(r.pred!.op).toBe("gt");
-    if (r.pred!.op === "gt") {
-      expect(r.pred!.b).toEqual(lit(-1));
-    }
-  });
-  it("3*4 = 12", () => {
-    expect(litValue(mul(numLit(3), numLit(4)))).toBe(12);
-  });
-  it("x>0 * 2 ⇒ (x*2)>0", () => {
-    const phi = gtNum(v("x"), 0);
-    const r = mul(numVar("x", gtNum(v("x"), 0)), numLit(2), phi);
-    expect(r.pred!.op).toBe("gt");
-    if (r.pred!.op === "gt") {
-      expect(r.pred!.b).toEqual(lit(0));
-    }
-  });
-});
-
-describe("implies", () => {
-  it("x>0 ⊢ x>0", () => {
-    expect(implies(gtNum(v("x"), 0), gtNum(v("x"), 0))).toBe(true);
-  });
-  it("x>0 ⊢ x≥0", () => {
-    expect(implies(gtNum(v("x"), 0), geNum(v("x"), 0))).toBe(true);
-  });
-  it("x>0 ⊬ x>5", () => {
-    expect(implies(gtNum(v("x"), 0), gtNum(v("x"), 5))).toBe(false);
-  });
-  it("x>5 ⊢ x>0", () => {
-    expect(implies(gtNum(v("x"), 5), gtNum(v("x"), 0))).toBe(true);
-  });
-  it("x>0 ⊢ x+1>1", () => {
-    const phi = gtNum(v("x"), 0);
-    expect(implies(phi, gtNum(app("+", [v("x"), lit(1)]), 1))).toBe(true);
-  });
-  it("x>0 ⊬ x+1>2", () => {
-    const phi = gtNum(v("x"), 0);
-    expect(implies(phi, gtNum(app("+", [v("x"), lit(1)]), 2))).toBe(false);
-  });
-});
-
-describe("cmp under phi", () => {
-  it("x>0, cmp(x, 0, >) → true", () => {
-    const phi = gtNum(v("x"), 0);
-    const r = cmp("gt", numVar("x"), numLit(0), phi);
-    expect(litValue(r)).toBe(true);
-  });
-  it("1<3 → true", () => {
-    expect(litValue(cmp("lt", numLit(1), numLit(3)))).toBe(true);
-  });
-});

package/src/algebra/__tests__/ast-eval.test.ts

@@ -1,154 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  analyzeFn,
-  numLit,
-  numVar,
-  gtNum,
-  geNum,
-  v,
-  lit,
-  termToString,
-  predToString,
-  litValue,
-  leakIfNeeded,
-  maybeLeak,
-  exceedsBudget,
-  termDepth,
-  termNodes,
-  app,
-  resetLeakCounter,
-  mul,
-  add,
-} from "../index.ts";
-
-describe("AST eval: source → Abs", () => {
-  it("add(1,3) from real source → 4", () => {
-    const src = `
-      const add = (a, b) => a + b;
-      function main() { return add(1, 3); }
-    `;
-    const r = analyzeFn(src, "main", []);
-    expect(litValue(r)).toBe(4);
-    expect(r.conf).toBe("exact");
-  });
-
-  it("scale(x) = add(x,1) under x>0 ⇒ (x+1)>1", () => {
-    const src = `
-      const add = (a, b) => a + b;
-      function scale(x) { return add(x, 1); }
-    `;
-    const phi = gtNum(v("x"), 0);
-    const r = analyzeFn(src, "scale", [numVar("x", gtNum(v("x"), 0))], phi);
-    expect(r.term).toBeDefined();
-    expect(termToString(r.term!)).toBe("(x + 1)");
-    expect(r.pred!.op).toBe("gt");
-    if (r.pred!.op === "gt") {
-      expect(r.pred!.b).toEqual(lit(1));
-    }
-  });
-
-  it("twice(x) nested add under x>0 ⇒ >2", () => {
-    const src = `
-      const add = (a, b) => a + b;
-      function twice(x) {
-        const c = add(x, 1);
-        return add(c, 1);
-      }
-    `;
-    const phi = gtNum(v("x"), 0);
-    const r = analyzeFn(src, "twice", [numVar("x", gtNum(v("x"), 0))], phi);
-    expect(r.term).toBeDefined();
-    expect(r.pred).toBeDefined();
-    // ((x+1)+1) > 2 或 (x+2) > 2
-    const ps = predToString(r.pred!);
-    expect(ps).toContain("2");
-  });
-
-  it("if (x > 5) return x; return 0  with x>10 ⇒ x", () => {
-    const src = `
-      function pick(x) {
-        if (x > 5) return x;
-        return 0;
-      }
-    `;
-    const phi = gtNum(v("x"), 10);
-    const r = analyzeFn(src, "pick", [numVar("x", gtNum(v("x"), 10))], phi);
-    // true 分支返回 x（term=x），false 分支 0；join 后丢 term
-    // 但 true 分支在 Φ 下 x>5 成立，我们至少得到 number
-    expect(r.shape).toEqual({ k: "prim", type: "number" });
-  });
-
-  it("if (x > 0) return x + 1; return 0  with Φ x>0 ⇒ true branch", () => {
-    const src = `
-      function addOneIfPositive(x) {
-        if (x > 0) return x + 1;
-        return 0;
-      }
-    `;
-    const phi = gtNum(v("x"), 0);
-    const r = analyzeFn(src, "addOneIfPositive", [numVar("x", gtNum(v("x"), 0))], phi);
-    expect(termToString(r.term!)).toBe("(x + 1)");
-    expect(r.pred!.op).toBe("gt");
-  });
-
-  it("literal only function", () => {
-    const src = `
-      function f() { return 1 + 2 * 3; }
-    `;
-    // 注意：JS 里 1+2*3 = 7，我们的 BinaryExpression 是左结合遍历
-    // Babel AST: (1 + (2 * 3)) —— 乘法优先，AST 已带优先级
-    const r = analyzeFn(src, "f", []);
-    expect(litValue(r)).toBe(7);
-  });
-
-  it("string concat from source", () => {
-    const src = `
-      function greet(name) { return "hi, " + name; }
-    `;
-    const r = analyzeFn(src, "greet", [numLit(1)]);
-    // number + string 在 JS 里是字符串，我们 isStrPrim 一侧即可
-    // 实参是 number，左侧是 string → 走 string 拼接
-    expect(r.shape).toEqual({ k: "prim", type: "string" });
-  });
-});
-
-describe("leak", () => {
-  it("small term does not leak", () => {
-    resetLeakCounter();
-    const t = app("+", [v("x"), lit(1)]);
-    expect(exceedsBudget(t)).toBe(false);
-    const a = add(numVar("x"), numLit(1));
-    const leaked = leakIfNeeded(a);
-    expect(leaked.term).toEqual(a.term);
-  });
-
-  it("deep term leaks to fresh var + eq", () => {
-    resetLeakCounter();
-    let t = v("x");
-    for (let i = 0; i < 10; i++) {
-      t = app("+", [t, lit(1)]);
-    }
-    expect(termDepth(t)).toBeGreaterThan(6);
-    expect(exceedsBudget(t)).toBe(true);
-
-    const a = { shape: { k: "prim" as const, type: "number" as const }, term: t, conf: "path" as const };
-    const leaked = maybeLeak(a, { maxDepth: 4, maxNodes: 20 }, "acc");
-    expect(leaked.term?.op).toBe("var");
-    if (leaked.term?.op === "var") {
-      expect(leaked.term.id.startsWith("acc$")).toBe(true);
-    }
-    expect(leaked.pred?.op).toBe("eq");
-  });
-});
-
-describe("mul negative flips bounds", () => {
-  it("x>0 * -2 ⇒ (x*-2) < 0", () => {
-    const phi = gtNum(v("x"), 0);
-    const r = mul(numVar("x", gtNum(v("x"), 0)), numLit(-2), phi);
-    expect(r.pred).toBeDefined();
-    expect(r.pred!.op).toBe("lt");
-    if (r.pred!.op === "lt") {
-      expect(r.pred!.b).toEqual(lit(0));
-    }
-  });
-});

package/src/algebra/__tests__/bridge.test.ts

@@ -1,160 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  absToTypeValue,
-  typeValueToAbs,
-  bridgeIsLossy,
-  getTvConfidence,
-  numLit,
-  numVar,
-  gtNum,
-  v,
-  litValue,
-  formatShape,
-  analyzeFn,
-  objOf,
-  strLit,
-  boolLit,
-} from "../index.ts";
-import { typeValueToString, T } from "../../type-value.ts";
-
-describe("bridge Abs → TypeValue", () => {
-  it("literal 4 → literal 4 #exact", () => {
-    const tv = absToTypeValue(numLit(4));
-    expect(tv.kind).toBe("literal");
-    if (tv.kind === "literal") expect(tv.value).toBe(4);
-    expect(getTvConfidence(tv)).toBe("exact");
-  });
-
-  it("plain number prim → primitive number", () => {
-    const tv = absToTypeValue({
-      shape: { k: "prim", type: "number" },
-      conf: "exact",
-    });
-    expect(typeValueToString(tv)).toBe("number");
-  });
-
-  it("x>0 with pred → refined number", () => {
-    const a = numVar("x", gtNum(v("x"), 0));
-    const tv = absToTypeValue(a);
-    // term 是 var，会丢 term；pred 可 encode 为 refined
-    expect(tv.kind === "refined" || tv.kind === "primitive").toBe(true);
-    const lossy = bridgeIsLossy(a);
-    // 丢 term 是预期的
-    expect(lossy.reasons.some((r) => r.includes("term"))).toBe(true);
-  });
-
-  it("object slots map to object TypeValue", () => {
-    const o = objOf({
-      host: { value: strLit("localhost") },
-      port: { value: numLit(8080) },
-      debug: { value: boolLit(false) },
-    });
-    const tv = absToTypeValue(o);
-    expect(tv.kind).toBe("object");
-    expect(typeValueToString(tv)).toContain("host");
-    expect(typeValueToString(tv)).toContain("8080");
-  });
-});
-
-describe("bridge TypeValue → Abs", () => {
-  it("literal 6 → Abs exact 6", () => {
-    const abs = typeValueToAbs(T.literal(6));
-    expect(litValue(abs)).toBe(6);
-    expect(abs.conf).toBe("exact");
-  });
-
-  it("primitive string → prim string", () => {
-    const abs = typeValueToAbs(T.string);
-    expect(formatShape(abs)).toBe("string");
-  });
-
-  it("object → obj slots", () => {
-    const abs = typeValueToAbs(
-      T.object({ a: T.literal(1), b: T.string }),
-    );
-    expect(abs.shape.k).toBe("obj");
-  });
-
-  it("round-trip literal", () => {
-    const tv = absToTypeValue(numLit(42));
-    const back = typeValueToAbs(tv);
-    expect(litValue(back)).toBe(42);
-  });
-
-  it("round-trip primitive (lossless)", () => {
-    const abs0 = {
-      shape: { k: "prim" as const, type: "number" as const },
-      conf: "exact" as const,
-    };
-    const tv = absToTypeValue(abs0);
-    const back = typeValueToAbs(tv);
-    expect(formatShape(back)).toBe("number");
-  });
-});
-
-describe("bridgeIsLossy", () => {
-  it("literal is not lossy", () => {
-    expect(bridgeIsLossy(numLit(1)).lossy).toBe(false);
-  });
-  it("symbolic term is lossy", () => {
-    const src = `
-      function scale(x) { return x + 1; }
-    `;
-    const r = analyzeFn(src, "scale", [numVar("x")]);
-    expect(bridgeIsLossy(r).lossy).toBe(true);
-  });
-});
-
-describe("bridge any / conf / refined reverse (rewrite closeout)", () => {
-  it("Abs any projects as unknown but keeps path conf (not partial)", () => {
-    const a: import("../abs.ts").Abs = { shape: { k: "any" }, conf: "path" };
-    const tv = absToTypeValue(a);
-    expect(tv.kind).toBe("unknown");
-    expect(getTvConfidence(tv)).toBe("path");
-  });
-
-  it("Abs analysis-fail unknown keeps partial conf", () => {
-    const a: import("../abs.ts").Abs = { shape: { k: "unknown" }, conf: "partial" };
-    const tv = absToTypeValue(a);
-    expect(tv.kind).toBe("unknown");
-    expect(getTvConfidence(tv)).toBe("partial");
-  });
-
-  it("widened TypeValue does not round-trip as exact", () => {
-    const src = `
-      function scale(x) { return x + 1; }
-    `;
-    const r = analyzeFn(src, "scale", [numVar("x")]);
-    const tv = absToTypeValue(r);
-    const back = typeValueToAbs(tv);
-    expect(back.conf === "exact").toBe(false);
-  });
-
-  it("refined numeric pred reverse-encodes into Abs pred", () => {
-    const a = numVar("x", gtNum(v("x"), 0));
-    const tv = absToTypeValue(a);
-    expect(tv.kind).toBe("refined");
-    const back = typeValueToAbs(tv);
-    expect(back.shape.k).toBe("prim");
-    expect(back.pred).toBeDefined();
-    expect(back.pred!.op).toBe("gt");
-    // pred 右端恢复为字面量 0
-    if (back.pred!.op === "gt") {
-      expect(back.pred!.b.op).toBe("lit");
-      if (back.pred!.b.op === "lit") expect(back.pred!.b.value).toBe(0);
-    }
-  });
-
-  it("refined le reverse-encodes", () => {
-    const a: import("../abs.ts").Abs = {
-      shape: { k: "prim", type: "number" },
-      term: v("n"),
-      pred: { op: "le", a: v("n"), b: { op: "lit", value: 10 } },
-      conf: "path",
-    };
-    const tv = absToTypeValue(a);
-    expect(tv.kind).toBe("refined");
-    const back = typeValueToAbs(tv);
-    expect(back.pred?.op).toBe("le");
-  });
-});