@nudojs/core 0.3.0 → 0.4.0

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

@@ -1,77 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  denoteGuard,
-  abs as makeAbs,
-  num,
-  str,
-  bool,
-  numLit,
-  strLit,
-  never,
-  unknown,
-  gt,
-  lit,
-  v as termVar,
-} from "@nudojs/core";
-
-describe("denoteGuard", () => {
-  it("prim number", () => {
-    expect(denoteGuard(num(), "x")).toBe('typeof x === "number"');
-  });
-
-  it("literal number keeps exact equality", () => {
-    expect(denoteGuard(numLit(8), "x")).toBe("x === 8");
-  });
-
-  it("literal string", () => {
-    expect(denoteGuard(strLit("hi"), "x")).toBe('x === "hi"');
-  });
-
-  it("object structure", () => {
-    const o = makeAbs(
-      { k: "obj", slots: { id: { value: num() }, name: { value: str() } } },
-      undefined,
-      undefined,
-      "exact",
-    );
-    const g = denoteGuard(o, "o");
-    expect(g).toContain('typeof o === "object"');
-    expect(g).toContain('typeof o.id === "number"');
-    expect(g).toContain('typeof o.name === "string"');
-  });
-
-  it("array element", () => {
-    const a = makeAbs({ k: "arr", element: num() }, undefined, undefined, "exact");
-    const g = denoteGuard(a, "a");
-    expect(g).toContain("Array.isArray(a)");
-    expect(g).toContain('typeof item === "number"');
-  });
-
-  it("sum is union of members", () => {
-    const s = makeAbs(
-      { k: "sum", members: [numLit(1), numLit(2)] },
-      undefined,
-      undefined,
-      "exact",
-    );
-    expect(denoteGuard(s, "x")).toBe("(x === 1 || x === 2)");
-  });
-
-  it("numeric pred: term > 0 on value", () => {
-    const a = makeAbs(
-      { k: "prim", type: "number" },
-      termVar("x"),
-      gt(termVar("x"), lit(0)),
-      "path",
-    );
-    const g = denoteGuard(a, "data");
-    expect(g).toContain('typeof data === "number"');
-    expect(g).toContain("data > 0");
-  });
-
-  it("never / unknown / bool", () => {
-    expect(denoteGuard(never, "x")).toBe("false");
-    expect(denoteGuard(unknown, "x")).toBe("true");
-    expect(denoteGuard(bool(), "x")).toBe('typeof x === "boolean"');
-  });
-});

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

@@ -1,64 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  checkCall,
-  checkArg,
-  formatDiagnostics,
-  numLit,
-  numVar,
-  gtNum,
-  v,
-  unknown,
-} from "../index.ts";
-
-const SRC = `
-function scale(x) {
-  return x + 1;
-}
-function needsPositive(x) {
-  if (x > 0) return x;
-  return 0;
-}
-`;
-
-describe("checkArg", () => {
-  it("literal 5 satisfies >0", () => {
-    const d = checkArg(numLit(5), gtNum(v("t"), 0));
-    expect(d).toBeUndefined();
-  });
-  it("literal -1 violates >0", () => {
-    const d = checkArg(numLit(-1), gtNum(v("t"), 0));
-    expect(d).toBeDefined();
-    expect(d!.severity).toBe("error");
-    expect(d!.code).toBe("nudo:constraint-violated");
-  });
-  it("unknown without term → opaque warning", () => {
-    const d = checkArg(unknown, gtNum(v("t"), 0));
-    expect(d?.code).toBe("nudo:arg-opaque");
-  });
-  it("symbolic x>0 satisfies >0 under Φ", () => {
-    const phi = gtNum(v("x"), 0);
-    const d = checkArg(numVar("x", gtNum(v("x"), 0)), gtNum(v("t"), 0), phi);
-    // expect 是 term>0，实参 term 是 var(x)，Φ ⊢ x>0 —— implies 需对齐 term
-    // 当前实现 expect 的 term 是 t，不是 x，所以可能 unproven
-    // 这里只要不 crash 即可；更严的对齐在后续
-    expect(d === undefined || d.code === "nudo:constraint-unproven").toBe(true);
-  });
-});
-
-describe("checkCall", () => {
-  it("unknown fn", () => {
-    const diags = checkCall(SRC, "nope", []);
-    expect(diags[0]?.code).toBe("nudo:fn-not-found");
-  });
-  it("arg count mismatch", () => {
-    const diags = checkCall(SRC, "scale", []);
-    expect(diags.some((d) => d.code === "nudo:arg-count")).toBe(true);
-  });
-  it("scale(5) has no constraint error", () => {
-    const diags = checkCall(SRC, "scale", [numLit(5)]);
-    expect(diags.filter((d) => d.severity === "error")).toEqual([]);
-  });
-  it("format empty", () => {
-    expect(formatDiagnostics([])).toBe("No issues found.");
-  });
-});

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

@@ -1,124 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { execFileSync } from "node:child_process";
-import { writeFileSync, mkdtempSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-  analyzeFn,
-  numLit,
-  litValue,
-  formatShape,
-} from "../index.ts";
-
-/**
- * 差分回归：同一段 JS，代数抽象求值 vs Node 真实执行。
- * 规则：若代数给出 exact 字面量，必须等于真实结果。
- * 若代数给出 prim(number)，真实结果必须是 number。
- */
-
-function runNode(code: string): unknown {
-  const dir = mkdtempSync(join(tmpdir(), "nudo-diff-"));
-  const file = join(dir, "run.mjs");
-  try {
-    writeFileSync(file, code);
-    const out = execFileSync(process.execPath, [file], { encoding: "utf8" });
-    return JSON.parse(out.trim());
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-}
-
-function absAndNode(
-  src: string,
-  fnName: string,
-  args: Array<number | string | boolean>,
-  callExpr: string,
-): { abs: ReturnType<typeof litValue>; shape: string; node: unknown } {
-  const absArgs = args.map((a) => numLit(a as number));
-  // string/bool 简化：测试里主要用 number
-  const result = analyzeFn(src, fnName, absArgs);
-  const node = runNode(`
-${src}
-console.log(JSON.stringify(${callExpr}));
-`);
-  return { abs: litValue(result), shape: formatShape(result), node };
-}
-
-describe("differential: algebra vs Node", () => {
-  it("add(1,3) → 4 both sides", () => {
-    const src = `function add(a,b){ return a+b; }`;
-    const r = absAndNode(src, "add", [1, 3], "add(1,3)");
-    expect(r.abs).toBe(4);
-    expect(r.node).toBe(4);
-  });
-
-  it("scale(5)=x+1 → 6", () => {
-    const src = `function scale(x){ return x+1; }`;
-    const r = absAndNode(src, "scale", [5], "scale(5)");
-    expect(r.abs).toBe(6);
-    expect(r.node).toBe(6);
-  });
-
-  it("twice(2) nested add → 4", () => {
-    const src = `
-function add(a,b){ return a+b; }
-function twice(x){ return add(add(x,1),1); }
-`;
-    const r = absAndNode(src, "twice", [2], "twice(2)");
-    // algebra: ((2+1)+1)=4
-    expect(r.abs).toBe(4);
-    expect(r.node).toBe(4);
-  });
-
-  it("mul precedence 1+2*3 → 7", () => {
-    const src = `function f(){ return 1+2*3; }`;
-    const r = absAndNode(src, "f", [], "f()");
-    expect(r.abs).toBe(7);
-    expect(r.node).toBe(7);
-  });
-
-  it("negate(5) → -5", () => {
-    const src = `function negate(x){ return x * -1; }`;
-    const r = absAndNode(src, "negate", [5], "negate(5)");
-    expect(r.abs).toBe(-5);
-    expect(r.node).toBe(-5);
-  });
-
-  it("if branch true: addOneIfPositive(3) → 4", () => {
-    const src = `
-function addOneIfPositive(x){
-  if (x > 0) return x + 1;
-  return 0;
-}
-`;
-    const r = absAndNode(src, "addOneIfPositive", [3], "addOneIfPositive(3)");
-    expect(r.abs).toBe(4);
-    expect(r.node).toBe(4);
-  });
-
-  it("if branch false: addOneIfPositive(-2) → 0", () => {
-    const src = `
-function addOneIfPositive(x){
-  if (x > 0) return x + 1;
-  return 0;
-}
-`;
-    const r = absAndNode(src, "addOneIfPositive", [-2], "addOneIfPositive(-2)");
-    expect(r.abs).toBe(0);
-    expect(r.node).toBe(0);
-  });
-
-  it("spread config exact fields", () => {
-    const src = `
-function createConfig(options){
-  return { host: "localhost", port: 8080, debug: false, ...options };
-}
-`;
-    // 代数用对象实参 —— 这里直接测字面量路径
-    const node = runNode(`
-${src}
-console.log(JSON.stringify(createConfig({ port: 3000 })));
-`);
-    expect(node).toEqual({ host: "localhost", port: 3000, debug: false });
-  });
-});

package/src/algebra/__tests__/div-mod.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { div, mod } from "../arithmetic.ts";
-import { numLit, num, abs } from "../abs.ts";
-import { v, lit } from "../term.ts";
-import { ge, pTrue } from "../pred.ts";
-import { typeValueToString } from "../../type-value.ts";
-import { absToTypeValue } from "../bridge.ts";
-import { formatAbs } from "../format.ts";
-
-describe("algebra div/mod", () => {
-  it("lit div", () => {
-    expect(formatAbs(div(numLit(10), numLit(2)))).toContain("5");
-  });
-
-  it("div by zero stays number", () => {
-    const r = div(numLit(1), numLit(0));
-    expect(r.shape).toEqual({ k: "prim", type: "number" });
-  });
-
-  it("x>=0 / 2 keeps lower bound", () => {
-    const x = abs(num().shape, v("x"), ge(v("x"), lit(0)), "path");
-    const half = div(x, numLit(2));
-    expect(half.pred).toBeDefined();
-    const tv = absToTypeValue(half);
-    expect(typeValueToString(tv)).toContain(">= 0");
-  });
-
-  it("lit mod", () => {
-    expect(formatAbs(mod(numLit(10), numLit(3)))).toContain("1");
-  });
-
-  it("x % 5 has bounds", () => {
-    const x = abs(num().shape, v("x"), pTrue, "path");
-    const r = mod(x, numLit(5));
-    expect(r.pred).toBeDefined();
-    expect(formatAbs(r)).toContain("5");
-  });
-});

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

@@ -1,103 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  add,
-  cmp,
-  numLit,
-  numVar,
-  strLit,
-  gtNum,
-  lit,
-  v,
-  termToString,
-  predToString,
-  litValue,
-} from "../index.ts";
-
-/**
- * 示例 0 金标：类型即计算
- *
- * add = (a, b) => a + b
- * add(1, 3)          → lit(4)                 #exact
- * Φ: x > 0
- * add(x, 1)          → term=x+1, pred:>1      #path
- * twice(x)           → term=(x+1)+1, pred:>2  #path
- */
-
-describe("Example 0: add is the computation itself", () => {
-  it("add(1, 3) evaluates to literal 4 #exact", () => {
-    const r = add(numLit(1), numLit(3));
-    expect(litValue(r)).toBe(4);
-    expect(r.conf).toBe("exact");
-    expect(r.term?.op).toBe("lit");
-    expect(r.shape).toEqual({ k: "prim", type: "number" });
-  });
-
-  it("add keeps term as (x + 1) when a is symbolic", () => {
-    const x = numVar("x");
-    const r = add(x, numLit(1));
-    expect(r.term).toBeDefined();
-    expect(termToString(r.term!)).toBe("(x + 1)");
-    expect(r.shape).toEqual({ k: "prim", type: "number" });
-    expect(r.conf).toBe("path");
-  });
-
-  it("Φ: x>0  ⇒  add(x,1) has pred term>1", () => {
-    const x = numVar("x", gtNum(v("x"), 0));
-    const phi = gtNum(v("x"), 0);
-    const r = add(x, numLit(1), phi);
-
-    expect(termToString(r.term!)).toBe("(x + 1)");
-    expect(r.pred).toBeDefined();
-    const ps = predToString(r.pred!);
-    expect(ps).toContain(">");
-    expect(ps).toContain("1");
-    expect(r.pred!.op).toBe("gt");
-    if (r.pred!.op === "gt") {
-      expect(termToString(r.pred!.a)).toBe("(x + 1)");
-      expect(r.pred!.b).toEqual(lit(1));
-    }
-    expect(r.conf).toBe("path");
-  });
-
-  it("twice: x>0 ⇒ (x+1)+1 with pred >2", () => {
-    const phi = gtNum(v("x"), 0);
-    const x = numVar("x", gtNum(v("x"), 0));
-
-    const c = add(x, numLit(1), phi);
-    const r = add(c, numLit(1), phi);
-
-    expect(r.term).toBeDefined();
-    const ts = termToString(r.term!);
-    expect(ts === "(x + 2)" || ts === "((x + 1) + 1)").toBe(true);
-
-    expect(r.pred).toBeDefined();
-    if (r.pred!.op === "gt") {
-      expect(r.pred!.b).toEqual(lit(2));
-    } else {
-      expect(predToString(r.pred!)).toContain("2");
-    }
-  });
-
-  it("non-negativity: x>0 ⇒ x+1 > 0 (weaker but still valid)", () => {
-    const phi = gtNum(v("x"), 0);
-    const x = numVar("x", gtNum(v("x"), 0));
-    const r = add(x, numLit(1), phi);
-    expect(r.pred!.op).toBe("gt");
-  });
-});
-
-describe("comparison implies under Φ", () => {
-  it("x>0 ⊢ x+1 > 1 is true", () => {
-    const phi = gtNum(v("x"), 0);
-    const x = numVar("x", gtNum(v("x"), 0));
-    const sum = add(x, numLit(1), phi);
-    const c = cmp("gt", sum, numLit(1), phi);
-    expect(litValue(c)).toBe(true);
-  });
-
-  it("string concat keeps string shape", () => {
-    const r = add(strLit("a"), strLit("b"));
-    expect(litValue(r)).toBe("ab");
-    expect(r.shape).toEqual({ k: "prim", type: "string" });
-  });
-});

package/src/algebra/__tests__/exec-analyze-throws.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  litValue,
-  absToString,
-  never,
-} from "@nudojs/core";
-
-describe("B-path analyze mode", () => {
-  it("does not run top-level side effects", () => {
-    const src = `
-globalThisNotDefined();
-export function id(x) { return x; }
-`;
-    expect(() => runTranspiled(src, { mode: "exec" })).toThrow();
-    const exports = runTranspiled(src, { mode: "analyze" });
-    expect(typeof exports.id).toBe("function");
-    const r = callTranspiledExportFull(exports, "id", [$lit(7)]);
-    expect(litValue(r.result)).toBe(7);
-  });
-
-  it("keeps function definitions that call other locals", () => {
-    const src = `
-function helper(x) { return x + 1; }
-export function go(n) { return helper(n); }
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", [$lit(1)]);
-    expect(litValue(r.result)).toBe(2);
-    expect(r.throws).toBe(never);
-  });
-});
-
-describe("B-path throws", () => {
-  it("captures $throw as throws Abs", () => {
-    const src = `
-export function fail(n) {
-  if (n > 0) { return n; } else { throw new Error("bad"); }
-}
-`;
-    // throw new Error → transpile may skip NewExpression; use throw literal path via $throw
-    const src2 = `
-export function fail(n) {
-  if (n > 0) { return n; } else { throw "bad"; }
-}
-`;
-    void src;
-    const exports = runTranspiled(src2, { mode: "analyze" });
-    const ok = callTranspiledExportFull(exports, "fail", [$lit(1)]);
-    expect(litValue(ok.result)).toBe(1);
-    expect(ok.throws).toBe(never);
-
-    const bad = callTranspiledExportFull(exports, "fail", [$lit(-1)]);
-    expect(bad.result.shape.k).toBe("never");
-    expect(bad.throws.shape.k).not.toBe("never");
-    expect(absToString(bad.throws)).toContain("bad");
-  });
-});

package/src/algebra/__tests__/exec-async.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  $await,
-  litValue,
-  absToString,
-} from "@nudojs/core";
-
-describe("B-path async / await", () => {
-  it("await async call unwraps to concrete", () => {
-    const src = `
-export async function f(n) {
-  return n + 1;
-}
-export async function go(n) {
-  return await f(n);
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", [$lit(1)]);
-    // go 是 async → 外层 promise
-    expect(absToString(r.result)).toContain("promise");
-    expect(litValue($await(r.result))).toBe(2);
-  });
-
-  it("async wraps return as promise", () => {
-    const src = `
-export async function f() {
-  return 42;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "f", []);
-    expect(absToString(r.result)).toContain("promise");
-    expect(litValue($await(r.result))).toBe(42);
-  });
-
-  it("transpiles async and await", async () => {
-    const { transpile } = await import("@nudojs/core");
-    const out = transpile(`export async function f(n) { return await g(n); }`);
-    expect(out).toContain("$async(");
-    expect(out).toContain("$await(");
-  });
-});