@nudojs/core 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/core",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Nudo type system: type-as-computation (Abs) with TypeValue evaluation IR",
   "type": "module",
   "license": "MIT",
@@ -11,11 +11,21 @@
     "abstract-interpretation",
     "type-system"
   ],
-  "main": "src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./exec": "./src/algebra/exec/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./exec": {
+      "types": "./dist/exec.d.ts",
+      "default": "./dist/exec.js"
+    }
   },
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nudojs/nudo.git",
@@ -32,7 +42,10 @@
     "@babel/parser": "^7.29.0",
     "@babel/types": "^7.29.0"
   },
+  "devDependencies": {
+    "commander": "^13.0.0"
+  },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts"
+    "build": "tsup"
   }
 }

package/CHANGELOG.md

@@ -1,34 +0,0 @@
-# @nudojs/core
-
-## 0.3.0
-
-### Minor Changes
-
-- 5786fa5: Promote the B-path (transpile + in-process Abs runtime) to the primary evaluation path for capable sources.
-
-  - Module graph now supports relative imports, bare-package harvest, default/namespace imports, re-exports, `export *`, require, cycle/depth/missing guards, and env modules (`path` / `node:path` etc.).
-  - Diagnostics, `@nudo:env` / mock injection, `call@` / `entry@` provenance, method-missing, unknown-recv, generators, classes, async/await, optional chaining, and destructuring run through B.
-  - When B hosts a file, `evaluateProgram` is skipped so TypeValue no longer double-reports.
-  - CLI `check` / `types` / `test` accept directories; check uses an Abs-only gate.
-  - LSP hover / `getTypeAtPosition` on capable files read the Abs node table; `*.nudo.js` edits evict L0 and recheck open parents.
-  - Public core surface now re-exports the algebra API (`Abs`, check, generalize, exec, bridge, `parseSource`, `stripTypes`).
-
-- 5786fa5: Speed up repeated analysis with layered memos and tighter cache contracts.
-
-  - Shared parse/AST LRU, `generalizeFromAst` L0–L3 (instantiate, α-equivalence, dep fingerprint + LRU), Abs module cache, and session-wide memos with an incremental after-edit path.
-  - Host cache-eviction contract, AST/function-fingerprint memory caps, conservative call-scan depth cap, and fail-open truncated dependency fingerprints.
-  - Fix session-memo staleness and identity holes so after-edit results stay correct.
-
-## 0.2.0
-
-### Minor Changes
-
-- 6c38283: docs and ci
-- 9f7f819: fix pkg info
-- c175f71: version
-
-## 0.1.0
-
-### Minor Changes
-
-- Conceptual design and basic implementation.

package/src/__tests__/environment.test.ts

@@ -1,48 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createEnvironment } from "../environment.ts";
-import { T, typeValueEquals } from "../type-value.ts";
-
-describe("Environment", () => {
-  it("binds and looks up values", () => {
-    const env = createEnvironment();
-    env.bind("x", T.literal(42));
-    expect(typeValueEquals(env.lookup("x"), T.literal(42))).toBe(true);
-  });
-
-  it("returns undefined for unbound names", () => {
-    const env = createEnvironment();
-    expect(typeValueEquals(env.lookup("x"), T.undefined)).toBe(true);
-  });
-
-  it("extends with child scope", () => {
-    const parent = createEnvironment();
-    parent.bind("x", T.literal(1));
-    const child = parent.extend({ y: T.literal(2) });
-    expect(typeValueEquals(child.lookup("x"), T.literal(1))).toBe(true);
-    expect(typeValueEquals(child.lookup("y"), T.literal(2))).toBe(true);
-  });
-
-  it("child binding shadows parent", () => {
-    const parent = createEnvironment();
-    parent.bind("x", T.literal(1));
-    const child = parent.extend({ x: T.literal(99) });
-    expect(typeValueEquals(child.lookup("x"), T.literal(99))).toBe(true);
-    expect(typeValueEquals(parent.lookup("x"), T.literal(1))).toBe(true);
-  });
-
-  it("has checks existence", () => {
-    const env = createEnvironment();
-    expect(env.has("x")).toBe(false);
-    env.bind("x", T.number);
-    expect(env.has("x")).toBe(true);
-  });
-
-  it("snapshot creates independent copy", () => {
-    const env = createEnvironment();
-    env.bind("x", T.literal(1));
-    const snap = env.snapshot();
-    env.bind("x", T.literal(2));
-    expect(typeValueEquals(snap.lookup("x"), T.literal(1))).toBe(true);
-    expect(typeValueEquals(env.lookup("x"), T.literal(2))).toBe(true);
-  });
-});

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

@@ -1,57 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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

@@ -1,84 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Ops, applyBinaryOp } from "../ops.ts";
-import { T, typeValueEquals } from "../type-value.ts";
-
-describe("Ops.add", () => {
-  it("adds two literal numbers", () => {
-    expect(typeValueEquals(Ops.add(T.literal(1), T.literal(2)), T.literal(3))).toBe(true);
-  });
-
-  it("concatenates two literal strings", () => {
-    expect(typeValueEquals(Ops.add(T.literal("a"), T.literal("b")), T.literal("ab"))).toBe(true);
-  });
-
-  it("returns number for abstract numbers", () => {
-    expect(typeValueEquals(Ops.add(T.number, T.number), T.number)).toBe(true);
-  });
-
-  it("returns string when one side is string", () => {
-    expect(typeValueEquals(Ops.add(T.number, T.string), T.string)).toBe(true);
-    expect(typeValueEquals(Ops.add(T.string, T.literal(1)), T.string)).toBe(true);
-  });
-});
-
-// sub/mul/div/mod 已删除：数值路径唯一真理在 algebra；非数应得 unknown。
-
-describe("Ops.strictEq / strictNeq", () => {
-  it("compares literals", () => {
-    expect(typeValueEquals(Ops.strictEq(T.literal(1), T.literal(1)), T.literal(true))).toBe(true);
-    expect(typeValueEquals(Ops.strictEq(T.literal(1), T.literal(2)), T.literal(false))).toBe(true);
-    expect(typeValueEquals(Ops.strictNeq(T.literal(1), T.literal(2)), T.literal(true))).toBe(true);
-  });
-
-  it("returns boolean for abstract operands", () => {
-    expect(typeValueEquals(Ops.strictEq(T.number, T.number), T.boolean)).toBe(true);
-  });
-});
-
-describe("Ops.gt / lt / gte / lte", () => {
-  it("compares literal numbers", () => {
-    expect(typeValueEquals(Ops.gt(T.literal(3), T.literal(2)), T.literal(true))).toBe(true);
-    expect(typeValueEquals(Ops.lt(T.literal(1), T.literal(2)), T.literal(true))).toBe(true);
-    expect(typeValueEquals(Ops.gte(T.literal(2), T.literal(2)), T.literal(true))).toBe(true);
-    expect(typeValueEquals(Ops.lte(T.literal(3), T.literal(2)), T.literal(false))).toBe(true);
-  });
-
-  it("returns boolean for abstract operands", () => {
-    expect(typeValueEquals(Ops.gt(T.number, T.number), T.boolean)).toBe(true);
-  });
-});
-
-describe("Ops.not", () => {
-  it("negates literal booleans", () => {
-    expect(typeValueEquals(Ops.not(T.literal(true)), T.literal(false))).toBe(true);
-    expect(typeValueEquals(Ops.not(T.literal(false)), T.literal(true))).toBe(true);
-  });
-
-  it("negates truthy/falsy literals", () => {
-    expect(typeValueEquals(Ops.not(T.literal(0)), T.literal(true))).toBe(true);
-    expect(typeValueEquals(Ops.not(T.literal("")), T.literal(true))).toBe(true);
-    expect(typeValueEquals(Ops.not(T.literal(1)), T.literal(false))).toBe(true);
-  });
-
-  it("returns boolean for abstract types", () => {
-    expect(typeValueEquals(Ops.not(T.number), T.boolean)).toBe(true);
-  });
-});
-
-// typeof_ / neg 已迁入 algebra surface（tryAbsUnary）
-
-describe("applyBinaryOp", () => {
-  it("dispatches to correct op", () => {
-    expect(typeValueEquals(applyBinaryOp("+", T.literal(1), T.literal(2)), T.literal(3))).toBe(true);
-    expect(typeValueEquals(applyBinaryOp("===", T.literal(1), T.literal(1)), T.literal(true))).toBe(true);
-  });
-
-  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-phase2.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  T,
-  isSubtypeOf,
-  deepCloneTypeValue,
-  mergeObjectProperties,
-  typeValueEquals,
-} from "../type-value.ts";
-
-describe("isSubtypeOf: structural subtyping", () => {
-  it("object subtype: a has all properties of b with subtypes", () => {
-    const a = T.object({ x: T.literal(1), y: T.string, z: T.boolean });
-    const b = T.object({ x: T.number, y: T.string });
-    expect(isSubtypeOf(a, b)).toBe(true);
-  });
-
-  it("object not subtype: missing property", () => {
-    const a = T.object({ x: T.number });
-    const b = T.object({ x: T.number, y: T.string });
-    expect(isSubtypeOf(a, b)).toBe(false);
-  });
-
-  it("object not subtype: property type mismatch", () => {
-    const a = T.object({ x: T.string });
-    const b = T.object({ x: T.number });
-    expect(isSubtypeOf(a, b)).toBe(false);
-  });
-
-  it("array subtype: element is subtype", () => {
-    const a = T.array(T.literal(1));
-    const b = T.array(T.number);
-    expect(isSubtypeOf(a, b)).toBe(true);
-  });
-
-  it("array not subtype: element mismatch", () => {
-    const a = T.array(T.string);
-    const b = T.array(T.number);
-    expect(isSubtypeOf(a, b)).toBe(false);
-  });
-
-  it("tuple subtype: element-wise", () => {
-    const a = T.tuple([T.literal(1), T.literal("hi")]);
-    const b = T.tuple([T.number, T.string]);
-    expect(isSubtypeOf(a, b)).toBe(true);
-  });
-
-  it("tuple not subtype: length mismatch", () => {
-    const a = T.tuple([T.number]);
-    const b = T.tuple([T.number, T.string]);
-    expect(isSubtypeOf(a, b)).toBe(false);
-  });
-
-  it("tuple is subtype of array if all elements match", () => {
-    const a = T.tuple([T.literal(1), T.literal(2)]);
-    const b = T.array(T.number);
-    expect(isSubtypeOf(a, b)).toBe(true);
-  });
-
-  it("tuple not subtype of array if element mismatch", () => {
-    const a = T.tuple([T.literal(1), T.literal("hi")]);
-    const b = T.array(T.number);
-    expect(isSubtypeOf(a, b)).toBe(false);
-  });
-});
-
-describe("deepCloneTypeValue", () => {
-  it("clones object with new id", () => {
-    const obj = T.object({ x: T.number, y: T.string });
-    const cloned = deepCloneTypeValue(obj);
-    expect(cloned.kind).toBe("object");
-    if (cloned.kind === "object" && obj.kind === "object") {
-      expect(cloned.id).not.toBe(obj.id);
-      expect(cloned.properties.x).toEqual(obj.properties.x);
-      expect(cloned.properties.y).toEqual(obj.properties.y);
-    }
-  });
-
-  it("clones nested objects", () => {
-    const inner = T.object({ a: T.literal(1) });
-    const outer = T.object({ nested: inner });
-    const cloned = deepCloneTypeValue(outer);
-    if (cloned.kind === "object" && outer.kind === "object") {
-      const clonedInner = cloned.properties.nested;
-      expect(clonedInner.kind).toBe("object");
-      if (clonedInner.kind === "object" && inner.kind === "object") {
-        expect(clonedInner.id).not.toBe(inner.id);
-      }
-    }
-  });
-
-  it("returns primitives unchanged", () => {
-    expect(deepCloneTypeValue(T.number)).toBe(T.number);
-    expect(typeValueEquals(deepCloneTypeValue(T.literal(1)), T.literal(1))).toBe(true);
-  });
-});
-
-describe("mergeObjectProperties", () => {
-  it("merges two objects with overlapping keys", () => {
-    const a = T.object({ x: T.literal(1), y: T.literal("a") }) as any;
-    const b = T.object({ x: T.literal(2), z: T.boolean }) as any;
-    const merged = mergeObjectProperties(a, b);
-    if (merged.kind === "object") {
-      expect(Object.keys(merged.properties).sort()).toEqual(["x", "y", "z"]);
-      expect(merged.properties.y).toEqual(T.literal("a"));
-      expect(merged.properties.z).toEqual(T.boolean);
-    }
-  });
-
-  it("creates union for overlapping keys with different values", () => {
-    const a = T.object({ x: T.literal(1) }) as any;
-    const b = T.object({ x: T.literal(2) }) as any;
-    const merged = mergeObjectProperties(a, b);
-    if (merged.kind === "object") {
-      expect(merged.properties.x.kind).toBe("union");
-    }
-  });
-});

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

@@ -1,94 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  T,
-  typeValueToString,
-  typeValueEquals,
-  isSubtypeOf,
-  getPrimitiveTypeOf,
-  deepCloneTypeValue,
-} from "../type-value.ts";
-
-describe("PromiseType", () => {
-  it("creates a promise type", () => {
-    const p = T.promise(T.number);
-    expect(p.kind).toBe("promise");
-    if (p.kind === "promise") {
-      expect(p.value).toBe(T.number);
-    }
-  });
-
-  it("toString formats correctly", () => {
-    expect(typeValueToString(T.promise(T.number))).toBe("Promise<number>");
-    expect(typeValueToString(T.promise(T.string))).toBe("Promise<string>");
-    expect(typeValueToString(T.promise(T.union(T.number, T.string)))).toBe(
-      "Promise<number | string>",
-    );
-  });
-
-  it("equals works", () => {
-    expect(typeValueEquals(T.promise(T.number), T.promise(T.number))).toBe(true);
-    expect(typeValueEquals(T.promise(T.number), T.promise(T.string))).toBe(false);
-  });
-
-  it("isSubtypeOf works", () => {
-    expect(isSubtypeOf(T.promise(T.literal(1)), T.promise(T.number))).toBe(true);
-    expect(isSubtypeOf(T.promise(T.number), T.promise(T.string))).toBe(false);
-  });
-
-  it("getPrimitiveTypeOf returns object", () => {
-    expect(getPrimitiveTypeOf(T.promise(T.number))).toBe("object");
-  });
-
-  it("deepClone works", () => {
-    const p = T.promise(T.object({ x: T.number }));
-    const cloned = deepCloneTypeValue(p);
-    expect(typeValueEquals(cloned, p)).toBe(false);
-    expect(cloned.kind).toBe("promise");
-    if (cloned.kind === "promise" && cloned.value.kind === "object") {
-      expect(cloned.value.properties.x).toBe(T.number);
-    }
-  });
-});
-
-describe("InstanceType", () => {
-  it("creates an instance type", () => {
-    const inst = T.instanceOf("Error", { message: T.literal("oops") });
-    expect(inst.kind).toBe("instance");
-    if (inst.kind === "instance") {
-      expect(inst.className).toBe("Error");
-      expect(inst.properties.message).toEqual(T.literal("oops"));
-    }
-  });
-
-  it("toString formats correctly", () => {
-    expect(typeValueToString(T.instanceOf("Error"))).toBe("Error");
-    expect(typeValueToString(T.instanceOf("Error", { message: T.literal("oops") }))).toBe(
-      'Error { message: "oops" }',
-    );
-  });
-
-  it("equals checks className", () => {
-    expect(typeValueEquals(T.instanceOf("Error"), T.instanceOf("Error"))).toBe(true);
-    expect(typeValueEquals(T.instanceOf("Error"), T.instanceOf("TypeError"))).toBe(false);
-  });
-
-  it("isSubtypeOf handles error hierarchy", () => {
-    expect(isSubtypeOf(T.instanceOf("TypeError"), T.instanceOf("Error"))).toBe(true);
-    expect(isSubtypeOf(T.instanceOf("SyntaxError"), T.instanceOf("Error"))).toBe(true);
-    expect(isSubtypeOf(T.instanceOf("Error"), T.instanceOf("TypeError"))).toBe(false);
-  });
-
-  it("getPrimitiveTypeOf returns object", () => {
-    expect(getPrimitiveTypeOf(T.instanceOf("Error"))).toBe("object");
-  });
-
-  it("deepClone works", () => {
-    const inst = T.instanceOf("Error", { message: T.string });
-    const cloned = deepCloneTypeValue(inst);
-    expect(cloned.kind).toBe("instance");
-    if (cloned.kind === "instance") {
-      expect(cloned.className).toBe("Error");
-      expect(cloned.properties.message).toBe(T.string);
-    }
-  });
-});