@nudojs/core 0.1.0 → 0.3.0

package/package.json

@@ -1,10 +1,36 @@
 {
   "name": "@nudojs/core",
-  "version": "0.1.0",
+  "version": "0.3.0",
+  "description": "Nudo type system: type-as-computation (Abs) with TypeValue evaluation IR",
   "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "nudo",
+    "type-inference",
+    "javascript",
+    "abstract-interpretation",
+    "type-system"
+  ],
   "main": "src/index.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./exec": "./src/algebra/exec/index.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nudojs/nudo.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/nudojs/nudo/tree/main/packages/core",
+  "bugs": "https://github.com/nudojs/nudo/issues",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.29.0",
+    "@babel/types": "^7.29.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"

package/src/__tests__/fn-sig-impl.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { T, getFnSig, isFnSig, typeValueEquals, typeValueToString } from "../index.ts";
+
+describe("T.fnSig with impl", () => {
+  it("creates fnSig without impl (backward compatible)", () => {
+    const fn = T.fnSig([T.number], T.string);
+    expect(isFnSig(fn)).toBe(true);
+    const sig = getFnSig(fn)!;
+    expect(sig.impl).toBeUndefined();
+    expect(typeValueEquals(sig.returnType, T.string)).toBe(true);
+  });
+
+  it("creates fnSig with impl", () => {
+    const fn = T.fnSig([T.number], T.number, T.never, (args) => {
+      if (args[0].kind === "literal" && typeof args[0].value === "number") {
+        return T.literal(args[0].value * 2);
+      }
+      return undefined;
+    });
+    expect(isFnSig(fn)).toBe(true);
+    const sig = getFnSig(fn)!;
+    expect(sig.impl).toBeDefined();
+  });
+
+  it("impl returns concrete value for literal args", () => {
+    const fn = T.fnSig([T.number], T.number, T.never, (args) => {
+      if (args[0].kind === "literal" && typeof args[0].value === "number") {
+        return T.literal(args[0].value * 2);
+      }
+      return undefined;
+    });
+    const sig = getFnSig(fn)!;
+    const result = sig.impl!([T.literal(5)]);
+    expect(result).toBeDefined();
+    expect(typeValueEquals(result!, T.literal(10))).toBe(true);
+  });
+
+  it("impl returns undefined for symbolic args (fallback to returnType)", () => {
+    const fn = T.fnSig([T.number], T.number, T.never, (args) => {
+      if (args[0].kind === "literal" && typeof args[0].value === "number") {
+        return T.literal(args[0].value * 2);
+      }
+      return undefined;
+    });
+    const sig = getFnSig(fn)!;
+    const result = sig.impl!([T.number]);
+    expect(result).toBeUndefined();
+  });
+
+  it("typeValueToString still works for fnSig with impl", () => {
+    const fn = T.fnSig([T.number, T.string], T.boolean, T.never, () => T.literal(true));
+    const str = typeValueToString(fn);
+    expect(str).toContain("number");
+    expect(str).toContain("string");
+    expect(str).toContain("boolean");
+  });
+});

package/src/__tests__/ops-refined.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueEquals } from "../type-value.ts";
+import { dispatchBinaryOp, dispatchMethod, dispatchProperty } from "../ops.ts";
+import { createTemplate, isTemplate } from "../refinements/template.ts";
+import { createRange } from "../refinements/range.ts";
+
+describe("dispatchBinaryOp", () => {
+  describe("refined fallback", () => {
+    it("falls back to base type when no ops defined", () => {
+      const odd = T.refine(T.number, { name: "odd", meta: {} });
+      const result = dispatchBinaryOp("+", odd, T.literal(1));
+      expect(result.kind).toBe("primitive");
+    });
+
+    it("uses custom ops when defined", () => {
+      const odd = T.refine(T.number, {
+        name: "odd",
+        meta: {},
+        ops: {
+          "%"(self, other) {
+            if (other.kind === "literal" && other.value === 2) return T.literal(1);
+            return undefined;
+          },
+        },
+      });
+      const result = dispatchBinaryOp("%", odd, T.literal(2));
+      expect(typeValueEquals(result, T.literal(1))).toBe(true);
+    });
+
+    it("falls back when custom op returns undefined", () => {
+      const odd = T.refine(T.number, {
+        name: "odd",
+        meta: {},
+        ops: {
+          "%"(self, other) {
+            if (other.kind === "literal" && other.value === 2) return T.literal(1);
+            return undefined;
+          },
+        },
+      });
+      // Ops.mod 已删：dispatchBinaryOp 的 % 最终落到 unknown；
+      // evaluator 侧由 evalBinaryValue 的 numberish 兜底补 number。
+      const result = dispatchBinaryOp("%", odd, T.literal(3));
+      expect(result.kind).toBe("unknown");
+    });
+  });
+
+  describe("template string via add", () => {
+    it("literal string + T.string produces template", () => {
+      const result = dispatchBinaryOp("+", T.literal("xy"), T.string);
+      expect(isTemplate(result)).toBe(true);
+    });
+
+    it("T.string + literal string produces template", () => {
+      const result = dispatchBinaryOp("+", T.string, T.literal("!"));
+      expect(isTemplate(result)).toBe(true);
+    });
+
+    it("template + template concatenates", () => {
+      const left = createTemplate([T.literal("a"), T.string]);
+      const right = createTemplate([T.literal("b"), T.string]);
+      const result = dispatchBinaryOp("+", left, right);
+      expect(isTemplate(result)).toBe(true);
+    });
+
+    it("two literal strings still produce literal", () => {
+      const result = dispatchBinaryOp("+", T.literal("a"), T.literal("b"));
+      expect(typeValueEquals(result, T.literal("ab"))).toBe(true);
+    });
+
+    it("T.string + T.string stays T.string", () => {
+      const result = dispatchBinaryOp("+", T.string, T.string);
+      expect(typeValueEquals(result, T.string)).toBe(true);
+    });
+  });
+
+  describe("range comparison ops", () => {
+    it("range(min:0) >= 0 is true", () => {
+      const r = createRange({ min: 0 });
+      const result = dispatchBinaryOp(">=", r, T.literal(0));
+      expect(typeValueEquals(result, T.literal(true))).toBe(true);
+    });
+
+    it("range(min:0) >= -1 is true", () => {
+      const r = createRange({ min: 0 });
+      const result = dispatchBinaryOp(">=", r, T.literal(-1));
+      expect(typeValueEquals(result, T.literal(true))).toBe(true);
+    });
+
+    it("range(max:100) > 200 is false", () => {
+      const r = createRange({ max: 100 });
+      const result = dispatchBinaryOp(">", r, T.literal(200));
+      expect(typeValueEquals(result, T.literal(false))).toBe(true);
+    });
+
+    it("range(min:0, max:100) > 50 is uncertain (boolean)", () => {
+      const r = createRange({ min: 0, max: 100 });
+      const result = dispatchBinaryOp(">", r, T.literal(50));
+      expect(typeValueEquals(result, T.boolean)).toBe(true);
+    });
+
+    it("range(max:10) <= 10 is true", () => {
+      const r = createRange({ max: 10 });
+      const result = dispatchBinaryOp("<=", r, T.literal(10));
+      expect(typeValueEquals(result, T.literal(true))).toBe(true);
+    });
+
+    it("range(min:5) < 3 is false", () => {
+      const r = createRange({ min: 5 });
+      const result = dispatchBinaryOp("<", r, T.literal(3));
+      expect(typeValueEquals(result, T.literal(false))).toBe(true);
+    });
+  });
+});
+
+describe("dispatchMethod", () => {
+  describe("template startsWith", () => {
+    it("known prefix matches", () => {
+      const tmpl = createTemplate([T.literal("xy"), T.string]);
+      const result = dispatchMethod(tmpl, "startsWith", [T.literal("x")]);
+      expect(result).toBeDefined();
+      expect(typeValueEquals(result!, T.literal(true))).toBe(true);
+    });
+
+    it("known prefix full match", () => {
+      const tmpl = createTemplate([T.literal("xy"), T.string]);
+      const result = dispatchMethod(tmpl, "startsWith", [T.literal("xy")]);
+      expect(typeValueEquals(result!, T.literal(true))).toBe(true);
+    });
+
+    it("known prefix mismatch", () => {
+      const tmpl = createTemplate([T.literal("xy"), T.string]);
+      const result = dispatchMethod(tmpl, "startsWith", [T.literal("a")]);
+      expect(typeValueEquals(result!, T.literal(false))).toBe(true);
+    });
+
+    it("uncertain when search extends beyond prefix", () => {
+      const tmpl = createTemplate([T.literal("xy"), T.string]);
+      const result = dispatchMethod(tmpl, "startsWith", [T.literal("xyz")]);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("template endsWith", () => {
+    it("known suffix matches", () => {
+      const tmpl = createTemplate([T.string, T.literal("!")]);
+      const result = dispatchMethod(tmpl, "endsWith", [T.literal("!")]);
+      expect(typeValueEquals(result!, T.literal(true))).toBe(true);
+    });
+
+    it("known suffix mismatch", () => {
+      const tmpl = createTemplate([T.string, T.literal("!")]);
+      const result = dispatchMethod(tmpl, "endsWith", [T.literal("?")]);
+      expect(typeValueEquals(result!, T.literal(false))).toBe(true);
+    });
+  });
+
+  describe("template includes", () => {
+    it("known fixed text includes substring", () => {
+      const tmpl = createTemplate([T.literal("hello"), T.string, T.literal("world")]);
+      const result = dispatchMethod(tmpl, "includes", [T.literal("hello")]);
+      expect(typeValueEquals(result!, T.literal(true))).toBe(true);
+    });
+
+    it("uncertain when not in fixed text", () => {
+      const tmpl = createTemplate([T.literal("hello"), T.string]);
+      const result = dispatchMethod(tmpl, "includes", [T.literal("xyz")]);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  it("returns undefined for unknown methods", () => {
+    const tmpl = createTemplate([T.literal("x"), T.string]);
+    const result = dispatchMethod(tmpl, "unknownMethod", []);
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined for non-refined types", () => {
+    const result = dispatchMethod(T.string, "startsWith", [T.literal("x")]);
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("dispatchProperty", () => {
+  it("template length returns range", () => {
+    const tmpl = createTemplate([T.literal("xy"), T.string]);
+    const result = dispatchProperty(tmpl, "length");
+    expect(result).toBeDefined();
+    expect(result!.kind).toBe("refined");
+  });
+
+  it("returns undefined for non-refined types", () => {
+    const result = dispatchProperty(T.string, "length");
+    expect(result).toBeUndefined();
+  });
+});

package/src/__tests__/ops.test.ts

@@ -21,19 +21,7 @@ describe("Ops.add", () => {
   });
 });
 
-describe("Ops.sub / mul / div / mod", () => {
-  it("computes literal arithmetic", () => {
-    expect(typeValueEquals(Ops.sub(T.literal(5), T.literal(3)), T.literal(2))).toBe(true);
-    expect(typeValueEquals(Ops.mul(T.literal(3), T.literal(4)), T.literal(12))).toBe(true);
-    expect(typeValueEquals(Ops.div(T.literal(10), T.literal(2)), T.literal(5))).toBe(true);
-    expect(typeValueEquals(Ops.mod(T.literal(7), T.literal(3)), T.literal(1))).toBe(true);
-  });
-
-  it("returns number for abstract operands", () => {
-    expect(typeValueEquals(Ops.sub(T.number, T.number), T.number)).toBe(true);
-    expect(typeValueEquals(Ops.mul(T.number, T.literal(2)), T.number)).toBe(true);
-  });
-});
+// sub/mul/div/mod 已删除：数值路径唯一真理在 algebra；非数应得 unknown。
 
 describe("Ops.strictEq / strictNeq", () => {
   it("compares literals", () => {
@@ -60,16 +48,6 @@ describe("Ops.gt / lt / gte / lte", () => {
   });
 });
 
-describe("Ops.typeof_", () => {
-  it("returns literal typeof for known types", () => {
-    expect(typeValueEquals(Ops.typeof_(T.literal(1)), T.literal("number"))).toBe(true);
-    expect(typeValueEquals(Ops.typeof_(T.literal("hi")), T.literal("string"))).toBe(true);
-    expect(typeValueEquals(Ops.typeof_(T.literal(null)), T.literal("object"))).toBe(true);
-    expect(typeValueEquals(Ops.typeof_(T.number), T.literal("number"))).toBe(true);
-    expect(typeValueEquals(Ops.typeof_(T.object({})), T.literal("object"))).toBe(true);
-  });
-});
-
 describe("Ops.not", () => {
   it("negates literal booleans", () => {
     expect(typeValueEquals(Ops.not(T.literal(true)), T.literal(false))).toBe(true);
@@ -87,15 +65,7 @@ describe("Ops.not", () => {
   });
 });
 
-describe("Ops.neg", () => {
-  it("negates literal number", () => {
-    expect(typeValueEquals(Ops.neg(T.literal(5)), T.literal(-5))).toBe(true);
-  });
-
-  it("returns number for abstract", () => {
-    expect(typeValueEquals(Ops.neg(T.number), T.number)).toBe(true);
-  });
-});
+// typeof_ / neg 已迁入 algebra surface（tryAbsUnary）
 
 describe("applyBinaryOp", () => {
   it("dispatches to correct op", () => {
@@ -103,7 +73,12 @@ describe("applyBinaryOp", () => {
     expect(typeValueEquals(applyBinaryOp("===", T.literal(1), T.literal(1)), T.literal(true))).toBe(true);
   });
 
-  it("returns unknown for unsupported op", () => {
+  it("returns unknown for deleted / unsupported ops", () => {
     expect(applyBinaryOp("**", T.number, T.number)).toEqual(T.unknown);
+    // sub/mul/div/mod 已从 Ops 删除，代数是唯一路径
+    expect(applyBinaryOp("-", T.literal(5), T.literal(3))).toEqual(T.unknown);
+    expect(applyBinaryOp("*", T.number, T.number)).toEqual(T.unknown);
+    expect(applyBinaryOp("/", T.literal(10), T.literal(2))).toEqual(T.unknown);
+    expect(applyBinaryOp("%", T.literal(7), T.literal(3))).toEqual(T.unknown);
   });
 });

package/src/__tests__/type-value-refined.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect } from "vitest";
+import {
+  T,
+  typeValueEquals,
+  isSubtypeOf,
+  typeValueToString,
+  deepCloneTypeValue,
+  getPrimitiveTypeOf,
+  getRefinedBase,
+} from "../type-value.ts";
+import { createTemplate, isTemplate, getTemplateParts, getKnownPrefix, getKnownSuffix } from "../refinements/template.ts";
+import { createRange, isRange, getRangeMeta } from "../refinements/range.ts";
+
+describe("Refined TypeValue", () => {
+  describe("T.refine", () => {
+    it("creates a refined type", () => {
+      const odd = T.refine(T.number, { name: "odd", meta: {} });
+      expect(odd.kind).toBe("refined");
+      if (odd.kind === "refined") {
+        expect(odd.base).toBe(T.number);
+        expect(odd.refinement.name).toBe("odd");
+      }
+    });
+  });
+
+  describe("typeValueEquals", () => {
+    it("equal refined types with same name and base", () => {
+      const a = T.refine(T.number, { name: "odd", meta: {} });
+      const b = T.refine(T.number, { name: "odd", meta: {} });
+      expect(typeValueEquals(a, b)).toBe(true);
+    });
+
+    it("different name means not equal", () => {
+      const a = T.refine(T.number, { name: "odd", meta: {} });
+      const b = T.refine(T.number, { name: "even", meta: {} });
+      expect(typeValueEquals(a, b)).toBe(false);
+    });
+
+    it("different base means not equal", () => {
+      const a = T.refine(T.number, { name: "x", meta: {} });
+      const b = T.refine(T.string, { name: "x", meta: {} });
+      expect(typeValueEquals(a, b)).toBe(false);
+    });
+  });
+
+  describe("isSubtypeOf", () => {
+    it("refined is subtype of its base", () => {
+      const odd = T.refine(T.number, { name: "odd", meta: {} });
+      expect(isSubtypeOf(odd, T.number)).toBe(true);
+    });
+
+    it("refined is subtype of unknown", () => {
+      const odd = T.refine(T.number, { name: "odd", meta: {} });
+      expect(isSubtypeOf(odd, T.unknown)).toBe(true);
+    });
+
+    it("literal is subtype of refined when check passes", () => {
+      const odd = T.refine(T.number, {
+        name: "odd",
+        meta: {},
+        check: (v) => typeof v === "number" && v % 2 !== 0,
+      });
+      expect(isSubtypeOf(T.literal(3), odd)).toBe(true);
+      expect(isSubtypeOf(T.literal(4), odd)).toBe(false);
+    });
+
+    it("nested refined is subtype of outer base", () => {
+      const integer = T.refine(T.number, { name: "integer", meta: {} });
+      const positiveInt = T.refine(integer, { name: "positive integer", meta: {} });
+      expect(isSubtypeOf(positiveInt, T.number)).toBe(true);
+      expect(isSubtypeOf(positiveInt, integer)).toBe(true);
+    });
+  });
+
+  describe("typeValueToString", () => {
+    it("uses refinement name", () => {
+      const odd = T.refine(T.number, { name: "odd", meta: {} });
+      expect(typeValueToString(odd)).toBe("odd");
+    });
+  });
+
+  describe("getPrimitiveTypeOf", () => {
+    it("delegates to base", () => {
+      const odd = T.refine(T.number, { name: "odd", meta: {} });
+      expect(getPrimitiveTypeOf(odd)).toBe("number");
+    });
+
+    it("handles nested refined", () => {
+      const inner = T.refine(T.string, { name: "inner", meta: {} });
+      const outer = T.refine(inner, { name: "outer", meta: {} });
+      expect(getPrimitiveTypeOf(outer)).toBe("string");
+    });
+  });
+
+  describe("getRefinedBase", () => {
+    it("unwraps to primitive", () => {
+      const inner = T.refine(T.number, { name: "a", meta: {} });
+      const outer = T.refine(inner, { name: "b", meta: {} });
+      expect(getRefinedBase(outer)).toBe(T.number);
+    });
+
+    it("returns non-refined as-is", () => {
+      expect(getRefinedBase(T.string)).toBe(T.string);
+    });
+  });
+
+  describe("deepCloneTypeValue", () => {
+    it("clones refined type", () => {
+      const odd = T.refine(T.number, { name: "odd", meta: { x: 1 } });
+      const cloned = deepCloneTypeValue(odd);
+      expect(typeValueEquals(cloned, odd)).toBe(true);
+      expect(cloned).not.toBe(odd);
+    });
+  });
+});
+
+describe("Template String", () => {
+  it("creates template from parts", () => {
+    const tmpl = createTemplate([T.literal("xy"), T.string]);
+    expect(isTemplate(tmpl)).toBe(true);
+    expect(tmpl.kind).toBe("refined");
+  });
+
+  it("collapses to literal when all parts are literal", () => {
+    const tmpl = createTemplate([T.literal("hello"), T.literal(" world")]);
+    expect(tmpl.kind).toBe("literal");
+    if (tmpl.kind === "literal") expect(tmpl.value).toBe("hello world");
+  });
+
+  it("collapses to T.string when only T.string", () => {
+    const tmpl = createTemplate([T.string]);
+    expect(tmpl.kind).toBe("primitive");
+  });
+
+  it("getKnownPrefix extracts leading literals", () => {
+    expect(getKnownPrefix([T.literal("xy"), T.string])).toBe("xy");
+    expect(getKnownPrefix([T.string, T.literal("z")])).toBe("");
+    expect(getKnownPrefix([T.literal("a"), T.literal("b"), T.string])).toBe("ab");
+  });
+
+  it("getKnownSuffix extracts trailing literals", () => {
+    expect(getKnownSuffix([T.string, T.literal("!")])).toBe("!");
+    expect(getKnownSuffix([T.literal("x"), T.string])).toBe("");
+  });
+
+  it("getTemplateParts returns parts", () => {
+    const tmpl = createTemplate([T.literal("x"), T.string]);
+    const parts = getTemplateParts(tmpl);
+    expect(parts).toHaveLength(2);
+  });
+
+  it("toString formats as template literal", () => {
+    const tmpl = createTemplate([T.literal("xy"), T.string]);
+    expect(typeValueToString(tmpl)).toBe("`xy${string}`");
+  });
+
+  it("is subtype of T.string", () => {
+    const tmpl = createTemplate([T.literal("x"), T.string]);
+    expect(isSubtypeOf(tmpl, T.string)).toBe(true);
+  });
+
+  it("check validates concrete strings", () => {
+    const tmpl = createTemplate([T.literal("xy"), T.string]);
+    if (tmpl.kind === "refined" && tmpl.refinement.check) {
+      expect(tmpl.refinement.check("xyhello")).toBe(true);
+      expect(tmpl.refinement.check("xy")).toBe(true);
+      expect(tmpl.refinement.check("ahello")).toBe(false);
+    }
+  });
+});
+
+describe("Range", () => {
+  it("creates range type", () => {
+    const r = createRange({ min: 0 });
+    expect(isRange(r)).toBe(true);
+    expect(r.kind).toBe("refined");
+  });
+
+  it("collapses to literal when min === max", () => {
+    const r = createRange({ min: 5, max: 5 });
+    expect(r.kind).toBe("literal");
+    if (r.kind === "literal") expect(r.value).toBe(5);
+  });
+
+  it("getRangeMeta returns metadata", () => {
+    const r = createRange({ min: 0, max: 100, integer: true });
+    const meta = getRangeMeta(r);
+    expect(meta).toEqual({ min: 0, max: 100, integer: true });
+  });
+
+  it("is subtype of T.number", () => {
+    const r = createRange({ min: 0 });
+    expect(isSubtypeOf(r, T.number)).toBe(true);
+  });
+
+  it("toString formats with constraints", () => {
+    expect(typeValueToString(createRange({ min: 0 }))).toBe("number (>= 0)");
+    expect(typeValueToString(createRange({ min: 0, max: 100 }))).toBe("number (>= 0, <= 100)");
+    expect(typeValueToString(createRange({ integer: true }))).toBe("integer");
+  });
+
+  it("check validates concrete numbers", () => {
+    const r = createRange({ min: 0, max: 10 });
+    if (r.kind === "refined" && r.refinement.check) {
+      expect(r.refinement.check(5)).toBe(true);
+      expect(r.refinement.check(-1)).toBe(false);
+      expect(r.refinement.check(11)).toBe(false);
+    }
+  });
+});