@nudojs/core 0.2.0 → 0.3.1

package/package.json

@@ -1,22 +1,51 @@
 {
   "name": "@nudojs/core",
-  "version": "0.2.0",
+  "version": "0.3.1",
+  "description": "Nudo type system: type-as-computation (Abs) with TypeValue evaluation IR",
   "type": "module",
-  "main": "src/index.ts",
+  "license": "MIT",
+  "keywords": [
+    "nudo",
+    "type-inference",
+    "javascript",
+    "abstract-interpretation",
+    "type-system"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/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",
     "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"
+  },
+  "devDependencies": {
+    "commander": "^13.0.0"
+  },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts"
+    "build": "tsup"
   }
 }

package/CHANGELOG.md

@@ -1,15 +0,0 @@
-# @nudojs/core
-
-## 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__/ops-refined.test.ts

@@ -1,194 +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;
-          },
-        },
-      });
-      const result = dispatchBinaryOp("%", odd, T.literal(3));
-      expect(result.kind).toBe("primitive");
-    });
-  });
-
-  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,109 +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);
-  });
-});
-
-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);
-  });
-});
-
-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.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);
-    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);
-  });
-});
-
-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);
-  });
-});
-
-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 unsupported op", () => {
-    expect(applyBinaryOp("**", T.number, T.number)).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);
-    }
-  });
-});