@kontor/kontor-sdk 1.0.0-alpha.39 → 1.0.0-alpha.40

package/src/wit/wit-parser/core/types/user-defined.test-d.ts

@@ -0,0 +1,1308 @@
+import { expectTypeOf, test } from "vitest";
+import type {
+  ParseTypes,
+  ParseRecords,
+  ParseVariants,
+  ParseEnums,
+} from "./user-defined.js";
+
+// ============================================================================
+// Enum Tests
+// ============================================================================
+
+test("ParseEnums - basic enum", () => {
+  expectTypeOf<
+    ParseEnums<["enum color { red, green, blue }"]>
+  >().toEqualTypeOf<{
+    color: readonly ["red", "green", "blue"];
+  }>();
+});
+
+test("ParseEnums - multiple enums", () => {
+  expectTypeOf<
+    ParseEnums<
+      [
+        "enum color { red, green, blue }",
+        "enum status { pending, complete, failed }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    color: readonly ["red", "green", "blue"];
+    status: readonly ["pending", "complete", "failed"];
+  }>();
+});
+
+// ============================================================================
+// Basic Record Tests
+// ============================================================================
+
+test("ParseRecords - basic records", () => {
+  expectTypeOf<
+    ParseRecords<
+      [
+        "record contract-address { name: string, height: s64, tx-index: s64 }",
+        "record token-pair { a: contract-address, b: contract-address }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    "contract-address": readonly [
+      {
+        readonly name: "name";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "height";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
+      {
+        readonly name: "tx-index";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
+    ];
+    "token-pair": readonly [
+      {
+        readonly name: "a";
+        readonly type: "contract-address";
+        readonly internalType: "contract-address";
+      },
+      {
+        readonly name: "b";
+        readonly type: "contract-address";
+        readonly internalType: "contract-address";
+      },
+    ];
+  }>();
+});
+
+test("ParseRecords - with generics", () => {
+  expectTypeOf<
+    ParseRecords<
+      [
+        "record contract-address { name: string, height: s64, tx-index: s64 }",
+        "record generic { as-list: list<contract-address>, as-option: option<contract-address>, as-result: result<contract-address, error> }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    "contract-address": readonly [
+      {
+        readonly name: "name";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "height";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
+      {
+        readonly name: "tx-index";
+        readonly type: "s64";
+        readonly internalType: "s64";
+      },
+    ];
+    generic: readonly [
+      {
+        readonly name: "as-list";
+        readonly type: "list<contract-address>";
+        readonly internalType: "list<contract-address>";
+      },
+      {
+        readonly name: "as-option";
+        readonly type: "option<contract-address>";
+        readonly internalType: "option<contract-address>";
+      },
+      {
+        readonly name: "as-result";
+        readonly type: "result<contract-address, error>";
+        readonly internalType: "result<contract-address, error>";
+      },
+    ];
+  }>();
+});
+
+// ============================================================================
+// Basic Variant Tests
+// ============================================================================
+
+test("ParseVariants - basic variants", () => {
+  expectTypeOf<
+    ParseVariants<
+      [
+        "variant response { ok(string), err(string) }",
+        "variant complex { success(response), failure(string) }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    response: readonly [
+      {
+        readonly name: "ok";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "err";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+    ];
+    complex: readonly [
+      {
+        readonly name: "success";
+        readonly type: "response";
+        readonly internalType: "response";
+      },
+      {
+        readonly name: "failure";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+    ];
+  }>();
+});
+
+test("ParseVariants - with unit cases", () => {
+  expectTypeOf<
+    ParseVariants<
+      [
+        "variant rainbow { red, orange, yellow, green, blue, indigo, violet }",
+        "variant color { hex(string), literal(rainbow) }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    rainbow: readonly [
+      { readonly name: "red"; readonly type: "_"; readonly internalType: "_" },
+      {
+        readonly name: "orange";
+        readonly type: "_";
+        readonly internalType: "_";
+      },
+      {
+        readonly name: "yellow";
+        readonly type: "_";
+        readonly internalType: "_";
+      },
+      {
+        readonly name: "green";
+        readonly type: "_";
+        readonly internalType: "_";
+      },
+      { readonly name: "blue"; readonly type: "_"; readonly internalType: "_" },
+      {
+        readonly name: "indigo";
+        readonly type: "_";
+        readonly internalType: "_";
+      },
+      {
+        readonly name: "violet";
+        readonly type: "_";
+        readonly internalType: "_";
+      },
+    ];
+    color: readonly [
+      {
+        readonly name: "hex";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "literal";
+        readonly type: "rainbow";
+        readonly internalType: "rainbow";
+      },
+    ];
+  }>();
+});
+
+test("ParseVariants - with generics", () => {
+  expectTypeOf<
+    ParseVariants<
+      [
+        "variant response { ok(string), err(string) }",
+        "variant envelope { maybe(option<string>), many(list<string>), nested(response) }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    response: readonly [
+      {
+        readonly name: "ok";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "err";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+    ];
+    envelope: readonly [
+      {
+        readonly name: "maybe";
+        readonly type: "option<string>";
+        readonly internalType: "option<string>";
+      },
+      {
+        readonly name: "many";
+        readonly type: "list<string>";
+        readonly internalType: "list<string>";
+      },
+      {
+        readonly name: "nested";
+        readonly type: "response";
+        readonly internalType: "response";
+      },
+    ];
+  }>();
+});
+
+// ============================================================================
+// Cross-Type Reference Tests
+// ============================================================================
+
+test("ParseTypes - record referencing variant", () => {
+  expectTypeOf<
+    ParseTypes<
+      [
+        "variant color { hex(string), literal(string) }",
+        "record palette { a: color, b: list<color> }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    records: {
+      palette: readonly [
+        {
+          readonly name: "a";
+          readonly type: "variant";
+          readonly internalType: "color";
+          readonly components: readonly [
+            {
+              readonly name: "hex";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "literal";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+          ];
+        },
+        {
+          readonly name: "b";
+          readonly type: "list<variant>";
+          readonly internalType: "list<color>";
+          readonly components: readonly [
+            {
+              readonly name: "hex";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "literal";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+          ];
+        },
+      ];
+    };
+    variants: {
+      color: readonly [
+        {
+          readonly name: "hex";
+          readonly type: "string";
+          readonly internalType: "string";
+        },
+        {
+          readonly name: "literal";
+          readonly type: "string";
+          readonly internalType: "string";
+        },
+      ];
+    };
+    enums: {};
+  }>();
+});
+
+test("ParseTypes - record referencing enum", () => {
+  expectTypeOf<
+    ParseTypes<
+      [
+        "enum color { red, green, blue }",
+        "record palette { primary: color, secondary: color }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    variants: {};
+    records: {
+      palette: readonly [
+        {
+          readonly name: "primary";
+          readonly type: "enum";
+          readonly internalType: "color";
+          readonly components: readonly [
+            { readonly name: "red"; readonly type: "_" },
+            { readonly name: "green"; readonly type: "_" },
+            { readonly name: "blue"; readonly type: "_" },
+          ];
+        },
+        {
+          readonly name: "secondary";
+          readonly type: "enum";
+          readonly internalType: "color";
+          readonly components: readonly [
+            { readonly name: "red"; readonly type: "_" },
+            { readonly name: "green"; readonly type: "_" },
+            { readonly name: "blue"; readonly type: "_" },
+          ];
+        },
+      ];
+    };
+    enums: {
+      color: readonly ["red", "green", "blue"];
+    };
+  }>();
+});
+
+test("ParseTypes - variant referencing enum", () => {
+  expectTypeOf<
+    ParseTypes<
+      [
+        "enum status { pending, complete, failed }",
+        "variant response { ok(status), err(string) }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    records: {};
+    variants: {
+      response: readonly [
+        {
+          readonly name: "ok";
+          readonly type: "enum";
+          readonly internalType: "status";
+          readonly components: readonly [
+            { readonly name: "pending"; readonly type: "_" },
+            { readonly name: "complete"; readonly type: "_" },
+            { readonly name: "failed"; readonly type: "_" },
+          ];
+        },
+        {
+          readonly name: "err";
+          readonly type: "string";
+          readonly internalType: "string";
+        },
+      ];
+    };
+    enums: {
+      status: readonly ["pending", "complete", "failed"];
+    };
+  }>();
+});
+
+test("ParseTypes - variant with nested record", () => {
+  expectTypeOf<
+    ParseTypes<
+      [
+        "record rgb { r: u8, g: u8, b: u8 }",
+        "variant color { hex(string), name(string), rgb(rgb) }",
+        "record palette { primary: color, secondary: color }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    enums: {};
+    records: {
+      rgb: readonly [
+        {
+          readonly name: "r";
+          readonly type: "u8";
+          readonly internalType: "u8";
+        },
+        {
+          readonly name: "g";
+          readonly type: "u8";
+          readonly internalType: "u8";
+        },
+        {
+          readonly name: "b";
+          readonly type: "u8";
+          readonly internalType: "u8";
+        },
+      ];
+      palette: readonly [
+        {
+          readonly name: "primary";
+          readonly type: "variant";
+          readonly internalType: "color";
+          readonly components: readonly [
+            {
+              readonly name: "hex";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "name";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "rgb";
+              readonly type: "record";
+              readonly internalType: "rgb";
+              readonly components: readonly [
+                {
+                  readonly name: "r";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+                {
+                  readonly name: "g";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+                {
+                  readonly name: "b";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+              ];
+            },
+          ];
+        },
+        {
+          readonly name: "secondary";
+          readonly type: "variant";
+          readonly internalType: "color";
+          readonly components: readonly [
+            {
+              readonly name: "hex";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "name";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "rgb";
+              readonly type: "record";
+              readonly internalType: "rgb";
+              readonly components: readonly [
+                {
+                  readonly name: "r";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+                {
+                  readonly name: "g";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+                {
+                  readonly name: "b";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+              ];
+            },
+          ];
+        },
+      ];
+    };
+    variants: {
+      color: readonly [
+        {
+          readonly name: "hex";
+          readonly type: "string";
+          readonly internalType: "string";
+        },
+        {
+          readonly name: "name";
+          readonly type: "string";
+          readonly internalType: "string";
+        },
+        {
+          readonly name: "rgb";
+          readonly type: "record";
+          readonly internalType: "rgb";
+          readonly components: readonly [
+            {
+              readonly name: "r";
+              readonly type: "u8";
+              readonly internalType: "u8";
+            },
+            {
+              readonly name: "g";
+              readonly type: "u8";
+              readonly internalType: "u8";
+            },
+            {
+              readonly name: "b";
+              readonly type: "u8";
+              readonly internalType: "u8";
+            },
+          ];
+        },
+      ];
+    };
+  }>();
+});
+
+test("ParseTypes - enum wrapped in generics", () => {
+  expectTypeOf<
+    ParseTypes<
+      [
+        "enum status { pending, complete, failed }",
+        "record task { current: status, history: list<status> }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    variants: {};
+    records: {
+      task: readonly [
+        {
+          readonly name: "current";
+          readonly type: "enum";
+          readonly internalType: "status";
+          readonly components: readonly [
+            { readonly name: "pending"; readonly type: "_" },
+            { readonly name: "complete"; readonly type: "_" },
+            { readonly name: "failed"; readonly type: "_" },
+          ];
+        },
+        {
+          readonly name: "history";
+          readonly type: "list<enum>";
+          readonly internalType: "list<status>";
+          readonly components: readonly [
+            { readonly name: "pending"; readonly type: "_" },
+            { readonly name: "complete"; readonly type: "_" },
+            { readonly name: "failed"; readonly type: "_" },
+          ];
+        },
+      ];
+    };
+    enums: {
+      status: readonly ["pending", "complete", "failed"];
+    };
+  }>();
+});
+
+// ============================================================================
+// Complex Mixed Type Tests
+// ============================================================================
+
+test("ParseTypes - all three types together", () => {
+  expectTypeOf<
+    ParseTypes<
+      [
+        "enum status { pending, complete, failed }",
+        "record user { name: string, status: status }",
+        "variant response { ok(user), err(string) }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    enums: {
+      status: readonly ["pending", "complete", "failed"];
+    };
+    records: {
+      user: readonly [
+        {
+          readonly name: "name";
+          readonly type: "string";
+          readonly internalType: "string";
+        },
+        {
+          readonly name: "status";
+          readonly type: "enum";
+          readonly internalType: "status";
+          readonly components: readonly [
+            {
+              readonly name: "pending";
+              readonly type: "_";
+            },
+            {
+              readonly name: "complete";
+              readonly type: "_";
+            },
+            {
+              readonly name: "failed";
+              readonly type: "_";
+            },
+          ];
+        },
+      ];
+    };
+
+    variants: {
+      response: readonly [
+        {
+          readonly name: "ok";
+          readonly type: "record";
+          readonly internalType: "user";
+          readonly components: readonly [
+            {
+              readonly name: "name";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "status";
+              readonly type: "enum";
+              readonly internalType: "status";
+              readonly components: readonly [
+                {
+                  readonly name: "pending";
+                  readonly type: "_";
+                },
+                {
+                  readonly name: "complete";
+                  readonly type: "_";
+                },
+                {
+                  readonly name: "failed";
+                  readonly type: "_";
+                },
+              ];
+            },
+          ];
+        },
+        {
+          readonly name: "err";
+          readonly type: "string";
+          readonly internalType: "string";
+        },
+      ];
+    };
+  }>();
+});
+
+test("ParseTypes - deeply nested types", () => {
+  expectTypeOf<
+    ParseTypes<
+      [
+        "enum color { red, green, blue }",
+        "record point { x: u32, y: u32 }",
+        "variant shape { circle(u32), colored(color) }",
+        "record canvas { shape: shape }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    enums: {
+      color: readonly ["red", "green", "blue"];
+    };
+    records: {
+      point: readonly [
+        {
+          readonly name: "x";
+          readonly type: "u32";
+          readonly internalType: "u32";
+        },
+        {
+          readonly name: "y";
+          readonly type: "u32";
+          readonly internalType: "u32";
+        },
+      ];
+      canvas: readonly [
+        {
+          readonly name: "shape";
+          readonly type: "variant";
+          readonly internalType: "shape";
+          readonly components: readonly [
+            {
+              readonly name: "circle";
+              readonly type: "u32";
+              readonly internalType: "u32";
+            },
+            {
+              readonly name: "colored";
+              readonly type: "enum";
+              readonly internalType: "color";
+              readonly components: readonly [
+                { readonly name: "red"; readonly type: "_" },
+                { readonly name: "green"; readonly type: "_" },
+                { readonly name: "blue"; readonly type: "_" },
+              ];
+            },
+          ];
+        },
+      ];
+    };
+    variants: {
+      shape: readonly [
+        {
+          readonly name: "circle";
+          readonly type: "u32";
+          readonly internalType: "u32";
+        },
+        {
+          readonly name: "colored";
+          readonly type: "enum";
+          readonly internalType: "color";
+          readonly components: readonly [
+            { readonly name: "red"; readonly type: "_" },
+            { readonly name: "green"; readonly type: "_" },
+            { readonly name: "blue"; readonly type: "_" },
+          ];
+        },
+      ];
+    };
+  }>();
+});
+
+// ============================================================================
+// Circular Reference Tests
+// ============================================================================
+
+test("ParseTypes - detects circular record reference", () => {
+  expectTypeOf<
+    ParseTypes<["record a { b: b }", "record b { a: a }"]>
+  >().toEqualTypeOf<{
+    records: {
+      a: readonly [
+        {
+          readonly name: "b";
+          readonly type: "record";
+          readonly internalType: "b";
+          readonly components: readonly [
+            {
+              readonly name: "a";
+              readonly type: "record";
+              readonly internalType: "a";
+              readonly components: readonly [
+                ['Error: Circular reference detected at "b".'],
+              ];
+            },
+          ];
+        },
+      ];
+      b: readonly [
+        {
+          readonly name: "a";
+          readonly type: "record";
+          readonly internalType: "a";
+          readonly components: readonly [
+            {
+              readonly name: "b";
+              readonly type: "record";
+              readonly internalType: "b";
+              readonly components: readonly [
+                ['Error: Circular reference detected at "a".'],
+              ];
+            },
+          ];
+        },
+      ];
+    };
+    variants: {};
+    enums: ParseEnums<["record a { b: b }", "record b { a: a }"]>;
+  }>();
+});
+
+test("ParseTypes - detects circular variant reference", () => {
+  type T = ParseTypes<["variant a { wraps(b) }", "variant b { wraps(a) }"]>;
+
+  expectTypeOf<T>().toEqualTypeOf<{
+    records: {};
+    variants: {
+      a: readonly [
+        {
+          readonly name: "wraps";
+          readonly type: "variant";
+          readonly internalType: "b";
+          readonly components: readonly [
+            {
+              readonly name: "wraps";
+              readonly type: "variant";
+              readonly internalType: "a";
+              readonly components: readonly [
+                ['Error: Circular reference detected at "b".'],
+              ];
+            },
+          ];
+        },
+      ];
+      b: readonly [
+        {
+          readonly name: "wraps";
+          readonly type: "variant";
+          readonly internalType: "a";
+          readonly components: readonly [
+            {
+              readonly name: "wraps";
+              readonly type: "variant";
+              readonly internalType: "b";
+              readonly components: readonly [
+                ['Error: Circular reference detected at "a".'],
+              ];
+            },
+          ];
+        },
+      ];
+    };
+    enums: {};
+  }>();
+});
+
+test("ParseTypes - detects circular reference across record and variant", () => {
+  expectTypeOf<
+    ParseTypes<["record r { value: v }", "variant v { wraps(r) }"]>
+  >().toMatchTypeOf<{
+    records: {
+      r: readonly [
+        {
+          readonly name: "value";
+          readonly type: "variant";
+          readonly internalType: "v";
+          readonly components: readonly [
+            {
+              readonly name: "wraps";
+              readonly type: "record";
+              readonly internalType: "r";
+              readonly components: readonly [
+                ['Error: Circular reference detected at "v".'],
+              ];
+            },
+          ];
+        },
+      ];
+    };
+    variants: {
+      v: readonly [
+        {
+          readonly name: "wraps";
+          readonly type: "record";
+          readonly internalType: "r";
+          readonly components: readonly [
+            {
+              readonly name: "value";
+              readonly type: "variant";
+              readonly internalType: "v";
+              readonly components: readonly [
+                ['Error: Circular reference detected at "r".'],
+              ];
+            },
+          ];
+        },
+      ];
+    };
+  }>();
+});
+
+test("ParseTypes - detects circular reference with enum in the chain", () => {
+  expectTypeOf<
+    ParseTypes<
+      [
+        "enum status { pending, complete }",
+        "record task { status: status, next: task }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    records: {
+      task: readonly [
+        {
+          readonly name: "status";
+          readonly type: "enum";
+          readonly internalType: "status";
+          readonly components: readonly [
+            {
+              readonly name: "pending";
+              readonly type: "_";
+            },
+            {
+              readonly name: "complete";
+              readonly type: "_";
+            },
+          ];
+        },
+        {
+          readonly name: "next";
+          readonly type: "record";
+          readonly internalType: "task";
+          readonly components: readonly [
+            {
+              readonly name: "status";
+              readonly type: "enum";
+              readonly internalType: "status";
+              readonly components: readonly [
+                {
+                  readonly name: "pending";
+                  readonly type: "_";
+                },
+                {
+                  readonly name: "complete";
+                  readonly type: "_";
+                },
+              ];
+            },
+            ['Error: Circular reference detected at "task".'],
+          ];
+        },
+      ];
+    };
+    enums: {
+      status: readonly ["pending", "complete"];
+    };
+    variants: {};
+  }>();
+});
+
+test("ParseTypes - detects multi-level circular reference", () => {
+  expectTypeOf<
+    ParseTypes<["record a { b: b }", "record b { c: c }", "record c { a: a }"]>
+  >().toEqualTypeOf<{
+    records: {
+      a: readonly [
+        {
+          readonly name: "b";
+          readonly type: "record";
+          readonly internalType: "b";
+          readonly components: readonly [
+            {
+              readonly name: "c";
+              readonly type: "record";
+              readonly internalType: "c";
+              readonly components: readonly [
+                {
+                  readonly name: "a";
+                  readonly type: "record";
+                  readonly internalType: "a";
+                  readonly components: readonly [
+                    ['Error: Circular reference detected at "b".'],
+                  ];
+                },
+              ];
+            },
+          ];
+        },
+      ];
+      b: readonly [
+        {
+          readonly name: "c";
+          readonly type: "record";
+          readonly internalType: "c";
+          readonly components: readonly [
+            {
+              readonly name: "a";
+              readonly type: "record";
+              readonly internalType: "a";
+              readonly components: readonly [
+                {
+                  readonly name: "b";
+                  readonly type: "record";
+                  readonly internalType: "b";
+                  readonly components: readonly [
+                    ['Error: Circular reference detected at "c".'],
+                  ];
+                },
+              ];
+            },
+          ];
+        },
+      ];
+      c: readonly [
+        {
+          readonly name: "a";
+          readonly type: "record";
+          readonly internalType: "a";
+          readonly components: readonly [
+            {
+              readonly name: "b";
+              readonly type: "record";
+              readonly internalType: "b";
+              readonly components: readonly [
+                {
+                  readonly name: "c";
+                  readonly type: "record";
+                  readonly internalType: "c";
+                  readonly components: readonly [
+                    ['Error: Circular reference detected at "a".'],
+                  ];
+                },
+              ];
+            },
+          ];
+        },
+      ];
+    };
+    variants: {};
+    enums: {};
+  }>();
+});
+
+/**
+ * This test file focuses on the specific issue where ParseVariants
+ * doesn't fully resolve record types within variant components.
+ *
+ * The issue: When a variant has a component like `rgb(rgb)` where
+ * the parameter type references a record, ParseVariants should:
+ * 1. Recognize it's a record type (✅ works)
+ * 2. Set internalType to the record name (❌ currently just "record")
+ * 3. Include components with the record's fields (❌ currently missing)
+ */
+
+test("ParseVariants - should NOT expand records (current behavior)", () => {
+  // This test documents the CURRENT (incorrect) behavior
+  type Result = ParseVariants<
+    [
+      "record rgb { r: u8, g: u8, b: u8 }",
+      "record hsv { h: u16, s: u8, v: u8 }",
+      "variant color { hex(string), rgb(rgb), hsv(hsv), named(string) }",
+    ]
+  >;
+
+  // Currently, ParseVariants doesn't expand the record definitions
+  // It just stores the type name without resolving the fields
+  expectTypeOf<Result>().toEqualTypeOf<{
+    color: readonly [
+      {
+        readonly name: "hex";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "rgb";
+        readonly type: "rgb"; // Just the type name
+        readonly internalType: "rgb";
+        // ❌ Missing: components with r, g, b fields
+      },
+      {
+        readonly name: "hsv";
+        readonly type: "hsv"; // Just the type name
+        readonly internalType: "hsv";
+        // ❌ Missing: components with h, s, v fields
+      },
+      {
+        readonly name: "named";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+    ];
+  }>();
+});
+
+test("ParseTypes - DOES expand records in variants (expected behavior)", () => {
+  // However, ParseTypes (which wraps ParseVariants) DOES expand them
+  type Result = ParseTypes<
+    [
+      "record rgb { r: u8, g: u8, b: u8 }",
+      "record hsv { h: u16, s: u8, v: u8 }",
+      "variant color { hex(string), rgb(rgb), hsv(hsv), named(string) }",
+    ]
+  >;
+
+  // ParseTypes correctly expands the record fields inline
+  expectTypeOf<Result["variants"]["color"]>().toEqualTypeOf<
+    readonly [
+      {
+        readonly name: "hex";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "rgb";
+        readonly type: "record"; // ✅ Becomes "record"
+        readonly internalType: "rgb"; // ✅ Preserves record name
+        readonly components: readonly [
+          // ✅ Has the record fields
+          {
+            readonly name: "r";
+            readonly type: "u8";
+            readonly internalType: "u8";
+          },
+          {
+            readonly name: "g";
+            readonly type: "u8";
+            readonly internalType: "u8";
+          },
+          {
+            readonly name: "b";
+            readonly type: "u8";
+            readonly internalType: "u8";
+          },
+        ];
+      },
+      {
+        readonly name: "hsv";
+        readonly type: "record"; // ✅ Becomes "record"
+        readonly internalType: "hsv"; // ✅ Preserves record name
+        readonly components: readonly [
+          // ✅ Has the record fields
+          {
+            readonly name: "h";
+            readonly type: "u16";
+            readonly internalType: "u16";
+          },
+          {
+            readonly name: "s";
+            readonly type: "u8";
+            readonly internalType: "u8";
+          },
+          {
+            readonly name: "v";
+            readonly type: "u8";
+            readonly internalType: "u8";
+          },
+        ];
+      },
+      {
+        readonly name: "named";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+    ]
+  >();
+});
+
+test("ParseTypes - records in variants are recursively expanded", () => {
+  // This is the same test from user-defined.test.ts that already passes
+  expectTypeOf<
+    ParseTypes<
+      [
+        "record rgb { r: u8, g: u8, b: u8 }",
+        "variant color { hex(string), name(string), rgb(rgb) }",
+        "record palette { primary: color, secondary: color }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    enums: {};
+    records: {
+      rgb: readonly [
+        {
+          readonly name: "r";
+          readonly type: "u8";
+          readonly internalType: "u8";
+        },
+        {
+          readonly name: "g";
+          readonly type: "u8";
+          readonly internalType: "u8";
+        },
+        {
+          readonly name: "b";
+          readonly type: "u8";
+          readonly internalType: "u8";
+        },
+      ];
+      palette: readonly [
+        {
+          readonly name: "primary";
+          readonly type: "variant";
+          readonly internalType: "color";
+          readonly components: readonly [
+            {
+              readonly name: "hex";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "name";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "rgb";
+              readonly type: "record";
+              readonly internalType: "rgb";
+              readonly components: readonly [
+                {
+                  readonly name: "r";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+                {
+                  readonly name: "g";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+                {
+                  readonly name: "b";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+              ];
+            },
+          ];
+        },
+        {
+          readonly name: "secondary";
+          readonly type: "variant";
+          readonly internalType: "color";
+          readonly components: readonly [
+            {
+              readonly name: "hex";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "name";
+              readonly type: "string";
+              readonly internalType: "string";
+            },
+            {
+              readonly name: "rgb";
+              readonly type: "record";
+              readonly internalType: "rgb";
+              readonly components: readonly [
+                {
+                  readonly name: "r";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+                {
+                  readonly name: "g";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+                {
+                  readonly name: "b";
+                  readonly type: "u8";
+                  readonly internalType: "u8";
+                },
+              ];
+            },
+          ];
+        },
+      ];
+    };
+    variants: {
+      color: readonly [
+        {
+          readonly name: "hex";
+          readonly type: "string";
+          readonly internalType: "string";
+        },
+        {
+          readonly name: "name";
+          readonly type: "string";
+          readonly internalType: "string";
+        },
+        {
+          readonly name: "rgb";
+          readonly type: "record";
+          readonly internalType: "rgb";
+          readonly components: readonly [
+            {
+              readonly name: "r";
+              readonly type: "u8";
+              readonly internalType: "u8";
+            },
+            {
+              readonly name: "g";
+              readonly type: "u8";
+              readonly internalType: "u8";
+            },
+            {
+              readonly name: "b";
+              readonly type: "u8";
+              readonly internalType: "u8";
+            },
+          ];
+        },
+      ];
+    };
+  }>();
+});