@ic-reactor/candid 3.0.9-beta.0 → 3.0.10-beta.1

package/src/visitor/returns/index.test.ts

@@ -1,22 +1,23 @@
 import { describe, it, expect } from "vitest"
-import { IDL } from "@icp-sdk/core/candid"
+import { IDL } from "../types"
 import { ResultFieldVisitor } from "./index"
 import type {
-  ResultField,
-  RecordResultField,
-  VariantResultField,
-  TupleResultField,
-  OptionalResultField,
-  VectorResultField,
-  BlobResultField,
-  RecursiveResultField,
-  NumberResultField,
-  TextResultField,
-  PrincipalResultField,
-  BooleanResultField,
-  NullResultField,
-  MethodResultMeta,
-  ServiceResultMeta,
+  ResultNode,
+  ResolvedNode,
+  RecordNode,
+  VariantNode,
+  TupleNode,
+  OptionalNode,
+  VectorNode,
+  BlobNode,
+  RecursiveNode,
+  NumberNode,
+  TextNode,
+  PrincipalNode,
+  BooleanNode,
+  NullNode,
+  MethodMeta,
+  ServiceMeta,
 } from "./types"
 
 describe("ResultFieldVisitor", () => {
@@ -35,33 +36,33 @@ describe("ResultFieldVisitor", () => {
       expect(field.label).toBe("message")
       expect(field.candidType).toBe("text")
       expect(field.displayType).toBe("string")
-      expect(field.textFormat).toBe("plain")
+      expect(field.format).toBe("plain")
     })
 
     it("should handle text with special label detection", () => {
       const emailField = visitor.visitText(IDL.Text, "email")
-      expect(emailField.textFormat).toBe("email")
+      expect(emailField.format).toBe("email")
 
       const urlField = visitor.visitText(IDL.Text, "website_url")
-      expect(urlField.textFormat).toBe("url")
+      expect(urlField.format).toBe("url")
 
       const phoneField = visitor.visitText(IDL.Text, "phone_number")
-      expect(phoneField.textFormat).toBe("phone")
+      expect(phoneField.format).toBe("phone")
 
       const uuidField = visitor.visitText(IDL.Text, "transaction_uuid")
-      expect(uuidField.textFormat).toBe("uuid")
+      expect(uuidField.format).toBe("uuid")
 
       const btcField = visitor.visitText(IDL.Text, "btc_address")
-      expect(btcField.textFormat).toBe("btc")
+      expect(btcField.format).toBe("btc")
 
       const ethField = visitor.visitText(IDL.Text, "ethereum_address")
-      expect(ethField.textFormat).toBe("eth")
+      expect(ethField.format).toBe("eth")
 
       const accountIdField = visitor.visitText(IDL.Text, "account_id")
-      expect(accountIdField.textFormat).toBe("account-id")
+      expect(accountIdField.format).toBe("account-id")
 
       const principalField = visitor.visitText(IDL.Text, "canister_id")
-      expect(principalField.textFormat).toBe("principal")
+      expect(principalField.format).toBe("principal")
     })
 
     it("should handle bool type", () => {
@@ -106,7 +107,7 @@ describe("ResultFieldVisitor", () => {
         expect(field.type).toBe("number")
         expect(field.candidType).toBe("nat")
         expect(field.displayType).toBe("string") // BigInt → string
-        expect(field.numberFormat).toBe("normal")
+        expect(field.format).toBe("normal")
       })
 
       it("should map int to string display type", () => {
@@ -191,30 +192,30 @@ describe("ResultFieldVisitor", () => {
     describe("Number format detection", () => {
       it("should detect timestamp format from label", () => {
         const timestampField = visitor.visitFixedNat(IDL.Nat64, "created_at")
-        expect(timestampField.numberFormat).toBe("timestamp")
+        expect(timestampField.format).toBe("timestamp")
 
         const dateField = visitor.visitNat(IDL.Nat, "timestamp_nanos")
-        expect(dateField.numberFormat).toBe("timestamp")
+        expect(dateField.format).toBe("timestamp")
 
         const deadlineField = visitor.visitNat(IDL.Nat, "deadline")
-        expect(deadlineField.numberFormat).toBe("timestamp")
+        expect(deadlineField.format).toBe("timestamp")
       })
 
       it("should detect cycle format from label", () => {
         const cycleField = visitor.visitNat(IDL.Nat, "cycles")
-        expect(cycleField.numberFormat).toBe("cycle")
+        expect(cycleField.format).toBe("cycle")
 
         // "cycle" as standalone word
         const cycleSingleField = visitor.visitNat(IDL.Nat, "cycle")
-        expect(cycleSingleField.numberFormat).toBe("cycle")
+        expect(cycleSingleField.format).toBe("cycle")
       })
 
       it("should default to normal format", () => {
         const amountField = visitor.visitNat(IDL.Nat, "amount")
-        expect(amountField.numberFormat).toBe("normal")
+        expect(amountField.format).toBe("normal")
 
         const countField = visitor.visitNat(IDL.Nat, "count")
-        expect(countField.numberFormat).toBe("normal")
+        expect(countField.format).toBe("normal")
       })
     })
   })
@@ -242,15 +243,15 @@ describe("ResultFieldVisitor", () => {
       expect(field.label).toBe("person")
       expect(field.candidType).toBe("record")
       expect(field.displayType).toBe("object")
-      expect(field.fields).toHaveLength(2)
+      expect(Object.keys(field.fields)).toHaveLength(2)
 
-      const nameField = field.fields.find((f) => f.label === "name")
+      const nameField = field.fields["name"]
       if (!nameField || nameField.type !== "text") {
         throw new Error("Name field not found or not text")
       }
       expect(nameField.displayType).toBe("string")
 
-      const ageField = field.fields.find((f) => f.label === "age")
+      const ageField = field.fields["age"]
       if (!ageField || ageField.type !== "number") {
         throw new Error("Age field not found or not number")
       }
@@ -277,14 +278,14 @@ describe("ResultFieldVisitor", () => {
 
       expect(field.type).toBe("record")
 
-      const addressField = field.fields.find((f) => f.label === "address")
+      const addressField = field.fields["address"] as RecordNode
       if (!addressField || addressField.type !== "record") {
         throw new Error("Address field not found or not a record")
       }
 
       expect(addressField.type).toBe("record")
       expect(addressField.displayType).toBe("object")
-      expect(addressField.fields).toHaveLength(2)
+      expect(Object.keys(addressField.fields)).toHaveLength(2)
     })
 
     it("should handle ICRC-1 account record", () => {
@@ -303,22 +304,23 @@ describe("ResultFieldVisitor", () => {
 
       expect(field.type).toBe("record")
 
-      const ownerField = field.fields.find((f) => f.label === "owner")
+      const ownerField = field.fields["owner"]
       if (!ownerField || ownerField.type !== "principal") {
         throw new Error("Owner field not found or not principal")
       }
       expect(ownerField.type).toBe("principal")
       expect(ownerField.displayType).toBe("string")
 
-      const subaccountField = field.fields.find((f) => f.label === "subaccount")
+      const subaccountField = field.fields["subaccount"] as OptionalNode
       if (!subaccountField || subaccountField.type !== "optional") {
         throw new Error("Subaccount field not found or not optional")
       }
       expect(subaccountField.type).toBe("optional")
-      if (subaccountField.innerField.type !== "blob") {
-        throw new Error("Subaccount inner field is not blob")
-      }
-      expect(subaccountField.innerField.type).toBe("blob")
+      // Resolve an example value to validate inner blob type
+      const subaccountResolved = subaccountField.resolve([
+        new Uint8Array([1, 2, 3]),
+      ])
+      expect((subaccountResolved.value as ResolvedNode).type).toBe("blob")
     })
   })
 
@@ -342,10 +344,14 @@ describe("ResultFieldVisitor", () => {
       expect(field.type).toBe("variant")
       expect(field.candidType).toBe("variant")
       expect(field.displayType).toBe("variant")
-      expect(field.options).toContain("Active")
-      expect(field.options).toContain("Inactive")
-      expect(field.options).toContain("Pending")
-      expect(field.options).toHaveLength(3)
+      // Validate options by resolving each option
+      const resolvedActive = field.resolve({ Active: null })
+      expect(resolvedActive.selected).toBe("Active")
+      expect(resolvedActive.selectedOption.type).toBe("null")
+      const resolvedInactive = field.resolve({ Inactive: null })
+      expect(resolvedInactive.selected).toBe("Inactive")
+      const resolvedPending = field.resolve({ Pending: null })
+      expect(resolvedPending.selected).toBe("Pending")
     })
 
     it("should handle variant with payloads", () => {
@@ -385,26 +391,19 @@ describe("ResultFieldVisitor", () => {
       )
 
       expect(field.type).toBe("variant")
-      expect(field.options).toContain("Transfer")
-      expect(field.options).toContain("Approve")
-      expect(field.options).toContain("Mint")
-      expect(field.options).toHaveLength(3)
-
-      const transferField = field.optionFields.find(
-        (f) => f.label === "Transfer"
-      )
-
-      if (!transferField || transferField.type !== "record") {
-        throw new Error("Transfer field not found or not record")
-      }
-      expect(transferField.type).toBe("record")
-      expect(transferField.fields).toHaveLength(3)
+      // Validate Transfer payload
+      const transferResolved = field.resolve({
+        Transfer: { from: "aaaaa-aa", to: "bbbbb-bb", amount: BigInt(1) },
+      })
+      expect(transferResolved.selected).toBe("Transfer")
+      expect(transferResolved.selectedOption.type).toBe("record")
+      expect(
+        Object.keys((transferResolved.selectedOption as RecordNode).fields)
+      ).toHaveLength(3)
 
-      const approveField = field.optionFields.find((f) => f.label === "Approve")
-      if (!approveField || approveField.type !== "number") {
-        throw new Error("Approve field not found or not number")
-      }
-      expect(approveField.type).toBe("number")
+      const approveResolved = field.resolve({ Approve: BigInt(5) })
+      expect(approveResolved.selected).toBe("Approve")
+      expect(approveResolved.selectedOption.type).toBe("number")
     })
 
     it("should detect Result variant (Ok/Err)", () => {
@@ -423,20 +422,16 @@ describe("ResultFieldVisitor", () => {
 
       expect(field.type).toBe("variant")
       expect(field.displayType).toBe("result") // Special result type
-      expect(field.options).toContain("Ok")
-      expect(field.options).toContain("Err")
 
-      const okField = field.optionFields.find((f) => f.label === "Ok")
-      if (!okField || okField.type !== "number") {
-        throw new Error("Ok field not found or not number")
-      }
-      expect(okField.displayType).toBe("string")
+      const okResolved = field.resolve({ Ok: BigInt(1) })
+      expect(okResolved.selected).toBe("Ok")
+      expect(okResolved.selectedOption.type).toBe("number")
+      expect(okResolved.selectedOption.displayType).toBe("string")
 
-      const errField = field.optionFields.find((f) => f.label === "Err")
-      if (!errField || errField.type !== "text") {
-        throw new Error("Err field not found or not text")
-      }
-      expect(errField.displayType).toBe("string")
+      const errResolved = field.resolve({ Err: "error" })
+      expect(errResolved.selected).toBe("Err")
+      expect(errResolved.selectedOption.type).toBe("text")
+      expect(errResolved.selectedOption.displayType).toBe("string")
     })
 
     it("should detect complex Result variant", () => {
@@ -475,17 +470,15 @@ describe("ResultFieldVisitor", () => {
 
       expect(field.displayType).toBe("result")
 
-      const okField = field.optionFields.find((f) => f.label === "Ok")
-      if (!okField || okField.type !== "record") {
-        throw new Error("Ok field not found or not record")
-      }
-      expect(okField.type).toBe("record")
+      const okResolved = field.resolve({
+        Ok: { id: BigInt(1), data: new Uint8Array([1, 2, 3]) },
+      })
+      expect(okResolved.selected).toBe("Ok")
+      expect(okResolved.selectedOption.type).toBe("record")
 
-      const errField = field.optionFields.find((f) => f.label === "Err")
-      if (!errField || errField.type !== "variant") {
-        throw new Error("Err field not found or not variant")
-      }
-      expect(errField.type).toBe("variant")
+      const errResolved = field.resolve({ Err: { NotFound: null } })
+      expect(errResolved.selected).toBe("Err")
+      expect(errResolved.selectedOption.type).toBe("variant")
     })
 
     it("should not detect non-Result variant with Ok and other options", () => {
@@ -516,9 +509,9 @@ describe("ResultFieldVisitor", () => {
       expect(field.type).toBe("tuple")
       expect(field.candidType).toBe("tuple")
       expect(field.displayType).toBe("array")
-      expect(field.fields).toHaveLength(2)
-      expect(field.fields[0].type).toBe("text")
-      expect(field.fields[1].type).toBe("number")
+      expect(field.items).toHaveLength(2)
+      expect(field.items[0].type).toBe("text")
+      expect(field.items[1].type).toBe("number")
     })
 
     it("should handle tuple with mixed types", () => {
@@ -534,17 +527,17 @@ describe("ResultFieldVisitor", () => {
         "data"
       )
 
-      expect(field.fields).toHaveLength(4)
-      expect(field.fields[0].type).toBe("principal")
-      expect(field.fields[1].type).toBe("number")
-      const numField = field.fields[1]
+      expect(field.items).toHaveLength(4)
+      expect(field.items[0].type).toBe("principal")
+      expect(field.items[1].type).toBe("number")
+      const numField = field.items[1]
       if (numField.type === "number") {
         expect(numField.displayType).toBe("string") // nat64 → string
       } else {
         throw new Error("Expected number field")
       }
-      expect(field.fields[2].type).toBe("boolean")
-      expect(field.fields[3].type).toBe("blob")
+      expect(field.items[2].type).toBe("boolean")
+      expect(field.items[3].type).toBe("blob")
     })
   })
 
@@ -556,7 +549,9 @@ describe("ResultFieldVisitor", () => {
       expect(field.type).toBe("optional")
       expect(field.candidType).toBe("opt")
       expect(field.displayType).toBe("nullable") // opt T → T | null
-      expect(field.innerField.type).toBe("text")
+      // Validate inner by resolving a value
+      const optResolved = field.resolve(["Bob"])
+      expect((optResolved.value as ResolvedNode).type).toBe("text")
     })
 
     it("should handle optional record", () => {
@@ -568,7 +563,9 @@ describe("ResultFieldVisitor", () => {
       const field = visitor.visitOpt(optType, recordInOpt, "metadata")
 
       expect(field.type).toBe("optional")
-      expect(field.innerField.type).toBe("record")
+      // Validate inner by resolving a record
+      const metaResolved = field.resolve([{ name: "x", value: BigInt(1) }])
+      expect((metaResolved.value as ResolvedNode).type).toBe("record")
     })
 
     it("should handle nested optional", () => {
@@ -577,13 +574,11 @@ describe("ResultFieldVisitor", () => {
       const field = visitor.visitOpt(optType, innerOpt, "maybeNumber")
 
       expect(field.type).toBe("optional")
-      expect(field.innerField.type).toBe("optional")
-      const inner = field.innerField
-      if (inner.type === "optional") {
-        expect(inner.innerField.type).toBe("number")
-      } else {
-        throw new Error("Inner field is not optional")
-      }
+      // Validate nested optional by resolving a nested array
+      const nestedResolved = field.resolve([[BigInt(1)]])
+      expect((nestedResolved.value as ResolvedNode).type).toBe("optional")
+      const innerResolved = nestedResolved.value as OptionalNode
+      expect((innerResolved.value as ResolvedNode).type).toBe("number")
     })
   })
 
@@ -595,11 +590,10 @@ describe("ResultFieldVisitor", () => {
       expect(field.type).toBe("vector")
       expect(field.candidType).toBe("vec")
       expect(field.displayType).toBe("array")
-      if (field.type === "vector") {
-        expect(field.itemField.type).toBe("text")
-      } else {
-        throw new Error("Field is not a vector")
-      }
+      // Validate items by resolving
+      const vecResolved = field.resolve(["a", "b", "c"]) as VectorNode
+      expect(vecResolved.items).toHaveLength(3)
+      expect(vecResolved.items[0].value).toBe("a")
     })
 
     it("should handle vector of records", () => {
@@ -611,11 +605,11 @@ describe("ResultFieldVisitor", () => {
       const field = visitor.visitVec(vecType, recType, "items")
 
       expect(field.type).toBe("vector")
-      if (field.type === "vector") {
-        expect(field.itemField.type).toBe("record")
-      } else {
-        throw new Error("Field is not a vector")
-      }
+      // Validate by resolving
+      const itemsResolved = field.resolve([
+        { id: BigInt(1), name: "x" },
+      ]) as VectorNode
+      expect(itemsResolved.items[0].type).toBe("record")
     })
 
     it("should handle blob (vec nat8)", () => {
@@ -625,11 +619,11 @@ describe("ResultFieldVisitor", () => {
       expect(field.type).toBe("blob")
       expect(field.candidType).toBe("blob")
       expect(field.displayType).toBe("string") // Blob → hex string
-      if (field.type === "blob") {
-        expect(field.displayHint).toBe("hex")
-      } else {
-        throw new Error("Field is not a blob")
-      }
+      // Validate by resolving a Uint8Array
+      const blobResolved = field.resolve(
+        new Uint8Array([0x12, 0x34, 0xab, 0xcd])
+      )
+      expect(blobResolved.value).toBe("1234abcd")
     })
 
     it("should handle nested vectors", () => {
@@ -638,11 +632,9 @@ describe("ResultFieldVisitor", () => {
       const field = visitor.visitVec(nestedVecType, innerVec, "matrix")
 
       expect(field.type).toBe("vector")
-      if (field.type === "vector") {
-        expect(field.itemField.type).toBe("vector")
-      } else {
-        throw new Error("Field is not a vector")
-      }
+      // Validate nested items via resolve
+      const nestedResolved = field.resolve([[BigInt(1)]]) as VectorNode
+      expect(nestedResolved.items[0].type).toBe("vector")
     })
 
     it("should handle vec of tuples (Map-like)", () => {
@@ -652,13 +644,15 @@ describe("ResultFieldVisitor", () => {
         mapType,
         tupleType,
         "metadata"
-      ) as VectorResultField
+      ) as VectorNode
 
       expect(field.type).toBe("vector")
-      expect(field.itemField.type).toBe("tuple")
-      const itemField = field.itemField
-      if (itemField.type === "tuple") {
-        expect(itemField.fields).toHaveLength(2)
+      // Validate by resolving a tuple item
+      const vecTupleResolved = field.resolve([["a", BigInt(1)]])
+      expect(vecTupleResolved.items[0].type).toBe("tuple")
+      const item = vecTupleResolved.items[0] as TupleNode
+      if (item.type === "tuple") {
+        expect(item.items).toHaveLength(2)
       } else {
         throw new Error("Item field is not tuple")
       }
@@ -693,17 +687,10 @@ describe("ResultFieldVisitor", () => {
       expect(field.type).toBe("recursive")
       expect(field.candidType).toBe("rec")
       expect(field.displayType).toBe("recursive")
-      expect(field.typeName).toBeDefined()
-      expect(typeof field.extract).toBe("function")
-
-      // Extract should return the variant
-      const extracted = field.extract()
-      if (extracted.type !== "variant") {
-        throw new Error("Extracted field is not variant")
-      }
-      expect(extracted.type).toBe("variant")
-      expect(extracted.options).toContain("Leaf")
-      expect(extracted.options).toContain("Node")
+      // Resolve to inspect inner schema
+      const treeResolved = field.resolve({ Leaf: BigInt(1) }) as RecursiveNode
+      expect(treeResolved.inner.type).toBe("variant")
+      expect((treeResolved.inner as VariantNode).selected).toBe("Leaf")
     })
 
     it("should handle recursive linked list", () => {
@@ -732,11 +719,9 @@ describe("ResultFieldVisitor", () => {
 
       expect(field.type).toBe("recursive")
 
-      const extracted = field.extract()
-      if (extracted.type !== "variant") {
-        throw new Error("Extracted field is not variant")
-      }
-      expect(extracted.options).toEqual(["Nil", "Cons"])
+      const listResolved = field.resolve({ Nil: null }) as RecursiveNode
+      expect(listResolved.inner.type).toBe("variant")
+      expect((listResolved.inner as VariantNode).selected).toBe("Nil")
     })
   })
 
@@ -752,11 +737,11 @@ describe("ResultFieldVisitor", () => {
       expect(meta.functionType).toBe("query")
       expect(meta.functionName).toBe("get_balance")
       expect(meta.returnCount).toBe(1)
-      expect(meta.resultFields).toHaveLength(1)
+      expect(meta.returns).toHaveLength(1)
 
-      expect(meta.resultFields).toHaveLength(1)
+      expect(meta.returns).toHaveLength(1)
 
-      const returnField = meta.resultFields[0]
+      const returnField = meta.returns[0]
       if (returnField.type === "number") {
         expect(returnField.candidType).toBe("nat")
         expect(returnField.displayType).toBe("string")
@@ -786,7 +771,7 @@ describe("ResultFieldVisitor", () => {
       expect(meta.functionType).toBe("update")
       expect(meta.returnCount).toBe(1)
 
-      const resultField = meta.resultFields[0]
+      const resultField = meta.returns[0]
       if (resultField.type === "variant") {
         expect(resultField.displayType).toBe("result")
       } else {
@@ -799,10 +784,10 @@ describe("ResultFieldVisitor", () => {
       const meta = visitor.visitFunc(funcType, "get_info")
 
       expect(meta.returnCount).toBe(3)
-      expect(meta.resultFields).toHaveLength(3)
-      expect(meta.resultFields[0].type).toBe("text")
-      expect(meta.resultFields[1].type).toBe("number")
-      expect(meta.resultFields[2].type).toBe("boolean")
+      expect(meta.returns).toHaveLength(3)
+      expect(meta.returns[0].type).toBe("text")
+      expect(meta.returns[1].type).toBe("number")
+      expect(meta.returns[2].type).toBe("boolean")
     })
 
     it("should handle function with no returns", () => {
@@ -810,7 +795,7 @@ describe("ResultFieldVisitor", () => {
       const meta = visitor.visitFunc(funcType, "log")
 
       expect(meta.returnCount).toBe(0)
-      expect(meta.resultFields).toHaveLength(0)
+      expect(meta.returns).toHaveLength(0)
     })
   })
 
@@ -852,8 +837,8 @@ describe("ResultFieldVisitor", () => {
       const getBalanceMeta = serviceMeta["get_balance"]
       expect(getBalanceMeta.functionType).toBe("query")
       expect(getBalanceMeta.returnCount).toBe(1)
-      expect(getBalanceMeta.resultFields[0].type).toBe("number")
-      const balanceField = getBalanceMeta.resultFields[0]
+      expect(getBalanceMeta.returns[0].type).toBe("number")
+      const balanceField = getBalanceMeta.returns[0]
       if (balanceField.type === "number") {
         expect(balanceField.displayType).toBe("string")
       } else {
@@ -867,7 +852,7 @@ describe("ResultFieldVisitor", () => {
       // Check get_metadata
       const getMetadataMeta = serviceMeta["get_metadata"]
       expect(getMetadataMeta.returnCount).toBe(1)
-      expect(getMetadataMeta.resultFields[0].type).toBe("vector")
+      expect(getMetadataMeta.returns[0].type).toBe("vector")
     })
   })
 
@@ -892,7 +877,7 @@ describe("ResultFieldVisitor", () => {
       expect(meta.functionType).toBe("query")
       expect(meta.returnCount).toBe(1)
 
-      const balanceField = meta.resultFields[0]
+      const balanceField = meta.returns[0]
       if (balanceField.type === "number") {
         expect(balanceField.candidType).toBe("nat")
         expect(balanceField.displayType).toBe("string")
@@ -942,23 +927,28 @@ describe("ResultFieldVisitor", () => {
 
       expect(field.displayType).toBe("result")
 
-      const okField = field.optionFields.find((f) => f.label === "Ok")
-
-      if (!okField || okField.type !== "number") {
+      const okResolved = field.resolve({ Ok: BigInt(123) })
+      if ((okResolved.selectedOption as ResolvedNode).type !== "number") {
         throw new Error("Ok field is not number")
       }
+      expect((okResolved.selectedOption as ResolvedNode).candidType).toBe("nat")
+      expect((okResolved.selectedOption as ResolvedNode).displayType).toBe(
+        "string"
+      )
 
-      expect(okField.candidType).toBe("nat")
-      expect(okField.displayType).toBe("string")
-
-      const errField = field.optionFields.find((f) => f.label === "Err")
-      if (!errField || errField.type !== "variant") {
-        throw new Error("Err field is not variant")
-      }
-
-      expect(errField.type).toBe("variant")
-      expect(errField.options).toContain("InsufficientFunds")
-      expect(errField.options).toContain("GenericError")
+      const errResolved = field.resolve({
+        Err: { InsufficientFunds: { balance: BigInt(0) } },
+      })
+      const innerErr = errResolved.selectedOption as ResolvedNode
+      expect(innerErr.type).toBe("variant")
+      const insufficient = (innerErr as any).resolve({
+        InsufficientFunds: { balance: BigInt(0) },
+      })
+      expect(insufficient.selected).toBe("InsufficientFunds")
+      const generic = (innerErr as any).resolve({
+        GenericError: { error_code: BigInt(1), message: "err" },
+      })
+      expect(generic.selected).toBe("GenericError")
     })
 
     it("should handle SNS canister status return", () => {
@@ -1011,45 +1001,46 @@ describe("ResultFieldVisitor", () => {
       expect(field.type).toBe("record")
 
       // Check status variant
-      const statusField = field.fields.find((f) => f.label === "status")
+      const statusField = field.fields["status"] as VariantNode
       if (!statusField || statusField.type !== "variant") {
-        throw new Error("Status field is not variant")
+        throw new Error("Status field not found or not variant")
       }
       expect(statusField.type).toBe("variant")
-      expect(statusField.options).toContain("running")
-      expect(statusField.options).toContain("stopping")
-      expect(statusField.options).toContain("stopped")
-      expect(statusField.options).toHaveLength(3)
+      expect(statusField.displayType).toBe("variant")
+      // Validate via resolving options
+      const statusResolved = statusField.resolve({ running: null })
+      expect(statusResolved.selected).toBe("running")
 
       // Check settings record
-      const settingsField = field.fields.find((f) => f.label === "settings")
+      const settingsField = field.fields["settings"] as RecordNode
       if (!settingsField || settingsField.type !== "record") {
-        throw new Error("Settings field is not record")
+        throw new Error("Settings field not found or not record")
       }
       expect(settingsField.type).toBe("record")
+      expect(settingsField.displayType).toBe("object")
 
-      const controllersField = settingsField.fields.find(
-        (f) => f.label === "controllers"
-      )
+      const controllersField = settingsField.fields["controllers"] as VectorNode
       if (!controllersField || controllersField.type !== "vector") {
-        throw new Error("Controllers field is not vector")
+        throw new Error("Controllers field not found or not vector")
       }
       expect(controllersField.type).toBe("vector")
-      expect(controllersField.itemField.type).toBe("principal")
+      // Validate item type via resolve
+      const controllersResolved = controllersField.resolve(["aaaaa-aa"])
+      expect(controllersResolved.items[0].type).toBe("principal")
 
       // Check cycles - should detect special format
-      const cyclesField = field.fields.find((f) => f.label === "cycles")
+      const cyclesField = field.fields["cycles"] as NumberNode
       if (!cyclesField || cyclesField.type !== "number") {
-        throw new Error("Cycles field is not number")
+        throw new Error("Cycles field not found or not number")
       }
-      expect(cyclesField.numberFormat).toBe("cycle")
+      expect(cyclesField.format).toBe("cycle")
 
       // Check module_hash - optional blob
-      const moduleHashField = field.fields.find(
-        (f) => f.label === "module_hash"
-      ) as OptionalResultField
+      const moduleHashField = field.fields["module_hash"] as OptionalNode
       expect(moduleHashField.type).toBe("optional")
-      expect(moduleHashField.innerField.type).toBe("blob")
+      // Validate via resolving a sample blob
+      const moduleHashResolved = moduleHashField.resolve([new Uint8Array([1])])
+      expect((moduleHashResolved.value as ResolvedNode).type).toBe("blob")
     })
 
     it("should handle complex governance proposal types", () => {
@@ -1114,12 +1105,10 @@ describe("ResultFieldVisitor", () => {
       )
 
       expect(field.type).toBe("record")
-      expect(field.fields.length).toBeGreaterThan(8)
+      expect(Object.keys(field.fields)).toHaveLength(12)
 
       // Check timestamp field (note: the label pattern matching may not match "proposal_timestamp_seconds")
-      const timestampField = field.fields.find(
-        (f) => f.label === "proposal_timestamp_seconds"
-      )
+      const timestampField = field.fields["proposal_timestamp_seconds"]
       if (!timestampField || timestampField.type !== "number") {
         throw new Error("Timestamp field not found or not number")
       }
@@ -1127,20 +1116,23 @@ describe("ResultFieldVisitor", () => {
       expect(timestampField.displayType).toBe("string") // nat64 → string
 
       // Check ballots - vec of tuples
-      const ballotsField = field.fields.find((f) => f.label === "ballots")
+      const ballotsField = field.fields["ballots"]
       if (!ballotsField || ballotsField.type !== "vector") {
         throw new Error("Ballots field not found or not vector")
       }
       expect(ballotsField.type).toBe("vector")
-      expect(ballotsField.itemField.type).toBe("tuple")
-
-      const ballotTuple = ballotsField.itemField
+      // Validate via resolve
+      const ballotsResolved = ballotsField.resolve([
+        [BigInt(1), { vote: 1, voting_power: BigInt(2) }],
+      ]) as TupleNode
+      expect(ballotsResolved.items).toHaveLength(1)
+      const ballotTuple = ballotsResolved.items[0] as TupleNode
       if (ballotTuple.type !== "tuple") {
         throw new Error("Ballot item is not tuple")
       }
-      expect(ballotTuple.fields).toHaveLength(2)
-      expect(ballotTuple.fields[0].type).toBe("number") // nat64
-      expect(ballotTuple.fields[1].type).toBe("record") // ballot record
+      expect(ballotTuple.items).toHaveLength(2)
+      expect(ballotTuple.items[0].type).toBe("number") // nat64
+      expect(ballotTuple.items[1].type).toBe("record") // ballot record
     })
   })
 
@@ -1179,7 +1171,7 @@ describe("ResultFieldVisitor", () => {
         if (typeof field === "object" && "displayType" in field) {
           expect(field.displayType).toBe(expectedDisplay)
         } else {
-          throw new Error("Expected a ResultField")
+          throw new Error("Expected as ResultNode")
         }
       })
     })
@@ -1194,40 +1186,30 @@ describe("ResultFieldVisitor", () => {
       it("should resolve text field with value", () => {
         const field = visitor.visitText(IDL.Text, "message")
         const resolved = field.resolve("Hello World")
-
-        expect(resolved.field).toBe(field)
         expect(resolved.value).toBe("Hello World")
       })
 
       it("should resolve number field with value", () => {
         const field = visitor.visitNat(IDL.Nat, "amount")
         const resolved = field.resolve(BigInt(1000000))
-
-        expect(resolved.field).toBe(field)
         expect(resolved.value).toBe("1000000")
       })
 
       it("should resolve boolean field with value", () => {
         const field = visitor.visitBool(IDL.Bool, "active")
         const resolved = field.resolve(true)
-
-        expect(resolved.field).toBe(field)
         expect(resolved.value).toBe(true)
       })
 
       it("should resolve null field", () => {
         const field = visitor.visitNull(IDL.Null, "empty")
         const resolved = field.resolve(null)
-
-        expect(resolved.field).toBe(field)
         expect(resolved.value).toBe(null)
       })
 
       it("should resolve principal field with string value", () => {
         const field = visitor.visitPrincipal(IDL.Principal, "owner")
         const resolved = field.resolve("aaaaa-aa")
-
-        expect(resolved.field).toBe(field)
         expect(resolved.value).toBe("aaaaa-aa")
       })
     })
@@ -1255,14 +1237,11 @@ describe("ResultFieldVisitor", () => {
           active: true,
         })
 
-        expect(resolved.field).toBe(field)
-        const value = resolved.value as Record<
-          string,
-          { field: ResultField; value: unknown }
-        >
-        expect(value.name.value).toBe("Alice")
-        expect(value.age.value).toBe(30)
-        expect(value.active.value).toBe(true)
+        expect(resolved.type).toBe(field.type)
+        const value = resolved.fields as Record<string, ResolvedNode>
+        expect(value["name"].value).toBe("Alice")
+        expect(value["age"].value).toBe(30)
+        expect(value["active"].value).toBe(true)
       })
 
       it("should handle null record value", () => {
@@ -1295,13 +1274,10 @@ describe("ResultFieldVisitor", () => {
         )
 
         const resolved = field.resolve({ Ok: "Success" })
-
-        const value = resolved.value as {
-          option: string
-          value: { field: ResultField; value: unknown }
-        }
-        expect(value.option).toBe("Ok")
-        expect(value.value.value).toBe("Success")
+        expect(resolved.type).toBe(field.type)
+        expect(resolved.selected).toBe("Ok")
+        const data = resolved.selectedOption as ResolvedNode
+        expect(data.value).toBe("Success")
       })
 
       it("should resolve variant with Err option", () => {
@@ -1320,12 +1296,9 @@ describe("ResultFieldVisitor", () => {
 
         const resolved = field.resolve({ Err: "Something went wrong" })
 
-        const value = resolved.value as {
-          option: string
-          value: { field: ResultField; value: unknown }
-        }
-        expect(value.option).toBe("Err")
-        expect(value.value.value).toBe("Something went wrong")
+        expect(resolved.selected).toBe("Err")
+        const data = resolved.selectedOption as ResolvedNode
+        expect(data.value).toBe("Something went wrong")
       })
 
       it("should handle null variant value", () => {
@@ -1356,11 +1329,8 @@ describe("ResultFieldVisitor", () => {
 
         const resolved = field.resolve(["hello", 123n, true])
 
-        expect(resolved.field).toBe(field)
-        const value = resolved.value as Array<{
-          field: ResultField
-          value: unknown
-        }>
+        expect(resolved.type).toBe(field.type)
+        const value = resolved.items as ResolvedNode[]
         expect(value).toHaveLength(3)
         expect(value[0].value).toBe("hello")
         expect(value[1].value).toBe("123")
@@ -1384,8 +1354,8 @@ describe("ResultFieldVisitor", () => {
 
         const resolved = field.resolve(["Bob"])
 
-        expect(resolved.field).toBe(field)
-        const inner = resolved.value as { field: ResultField; value: unknown }
+        expect(resolved.type).toBe(field.type)
+        const inner = resolved.value as ResolvedNode
         expect(inner.value).toBe("Bob")
       })
 
@@ -1394,8 +1364,6 @@ describe("ResultFieldVisitor", () => {
         const field = visitor.visitOpt(optType, IDL.Text, "nickname")
 
         const resolved = field.resolve(null)
-
-        expect(resolved.field).toBe(field)
         expect(resolved.value).toBe(null)
       })
     })
@@ -1405,13 +1373,10 @@ describe("ResultFieldVisitor", () => {
         const vecType = IDL.Vec(IDL.Text)
         const field = visitor.visitVec(vecType, IDL.Text, "tags")
 
-        const resolved = field.resolve(["a", "b", "c"])
+        const resolved = field.resolve(["a", "b", "c"]) as VectorNode
 
-        expect(resolved.field).toBe(field)
-        const value = resolved.value as Array<{
-          field: ResultField
-          value: unknown
-        }>
+        expect(resolved.type).toBe(field.type)
+        const value = resolved.items as ResolvedNode[]
         expect(value).toHaveLength(3)
         expect(value[0].value).toBe("a")
         expect(value[1].value).toBe("b")
@@ -1422,12 +1387,11 @@ describe("ResultFieldVisitor", () => {
         const vecType = IDL.Vec(IDL.Nat)
         const field = visitor.visitVec(vecType, IDL.Nat, "numbers")
 
-        const resolved = field.resolve([])
+        const resolved = field.resolve([]) as VectorNode
 
-        const value = resolved.value as Array<{
-          field: ResultField
-          value: unknown
-        }>
+        expect(resolved.type).toBe(field.type)
+
+        const value = resolved.items as ResolvedNode[]
         expect(value).toHaveLength(0)
       })
 
@@ -1448,7 +1412,7 @@ describe("ResultFieldVisitor", () => {
 
         const resolved = field.resolve(new Uint8Array([0x12, 0x34, 0xab, 0xcd]))
 
-        expect(resolved.field).toBe(field)
+        expect(resolved.type).toBe(field.type)
         expect(resolved.value).toBe("1234abcd")
       })
     })
@@ -1479,7 +1443,7 @@ describe("ResultFieldVisitor", () => {
         })
 
         // The recursive type should delegate to its inner record type
-        expect(resolved.field.type).toBe("record")
+        expect(resolved.type).toBe("recursive")
       })
     })
 
@@ -1519,29 +1483,24 @@ describe("ResultFieldVisitor", () => {
           },
         })
 
-        const value = resolved.value as Record<
-          string,
-          { field: ResultField; value: unknown }
-        >
-        const userValue = value.user.value as Record<
-          string,
-          { field: ResultField; value: unknown }
-        >
-        const profileValue = userValue.profile.value as Record<
-          string,
-          { field: ResultField; value: unknown }
-        >
-        expect(profileValue.name.value).toBe("Alice")
-        expect(profileValue.verified.value).toBe(true)
+        const value = resolved.fields as Record<string, ResolvedNode>
+        const userNode = value.user as RecordNode
+        if (userNode.type !== "record") {
+          throw new Error("User node is not a record")
+        }
+        const profileNode = userNode.fields["profile"] as RecordNode
+        const profileFields = profileNode.fields as Record<string, ResolvedNode>
+        expect(profileFields["name"].value).toBe("Alice")
+        expect(profileFields["verified"].value).toBe(true)
       })
     })
   })
 
   // ════════════════════════════════════════════════════════════════════════
-  // generateMetadata() Method Tests
+  // resolve() Method Tests
   // ════════════════════════════════════════════════════════════════════════
 
-  describe("generateMetadata() Method", () => {
+  describe("resolve() Method", () => {
     it("should generate metadata for single return value", () => {
       const service = IDL.Service({
         getName: IDL.Func([], [IDL.Text], ["query"]),
@@ -1552,13 +1511,13 @@ describe("ResultFieldVisitor", () => {
       )
       const methodMeta = serviceMeta["getName"]
 
-      const result = methodMeta.generateMetadata("Alice")
+      const result = methodMeta.resolve("Alice")
 
       expect(result.functionName).toBe("getName")
       expect(result.functionType).toBe("query")
       expect(result.results).toHaveLength(1)
       expect(result.results[0].value).toBe("Alice")
-      expect(result.results[0].field.type).toBe("text")
+      expect(result.results[0].type).toBe("text")
     })
 
     it("should generate metadata for multiple return values", () => {
@@ -1571,18 +1530,14 @@ describe("ResultFieldVisitor", () => {
       )
       const methodMeta = serviceMeta["getStats"]
 
-      const result = methodMeta.generateMetadata([
-        BigInt(100),
-        BigInt(200),
-        "active",
-      ])
+      const result = methodMeta.resolve([BigInt(100), BigInt(200), "active"])
 
       expect(result.results).toHaveLength(3)
       expect(result.results[0].value).toBe("100")
-      expect(result.results[0].field.type).toBe("number")
+      expect(result.results[0].type).toBe("number")
       expect(result.results[1].value).toBe("200")
       expect(result.results[2].value).toBe("active")
-      expect(result.results[2].field.type).toBe("text")
+      expect(result.results[2].type).toBe("text")
     })
 
     it("should generate metadata for record return value", () => {
@@ -1599,22 +1554,19 @@ describe("ResultFieldVisitor", () => {
       )
       const methodMeta = serviceMeta["getUser"]
 
-      const result = methodMeta.generateMetadata({
+      const result = methodMeta.resolve({
         name: "Bob",
         balance: BigInt(1000),
       })
 
       expect(result.results).toHaveLength(1)
-      expect(result.results[0].field.type).toBe("record")
+      expect(result.results[0].type).toBe("record")
 
-      const recordValue = result.results[0].value
-      if (typeof recordValue !== "object" || recordValue === null) {
-        throw new Error("Expected record value object")
+      const recordNode = result.results[0] as RecordNode
+      if (recordNode.type !== "record") {
+        throw new Error("Expected record node")
       }
-      const val = recordValue as Record<
-        string,
-        { field: ResultField; value: unknown }
-      >
+      const val = recordNode.fields as Record<string, ResolvedNode>
       expect(val.name.value).toBe("Bob")
       expect(val.balance.value).toBe("1000")
     })
@@ -1634,31 +1586,29 @@ describe("ResultFieldVisitor", () => {
       const methodMeta = serviceMeta["transfer"]
 
       // Test Ok case
-      const okResult = methodMeta.generateMetadata({ Ok: BigInt(12345) })
-      expect(okResult.results[0].field.type).toBe("variant")
-      if (okResult.results[0].field.type === "variant") {
-        expect(okResult.results[0].field.displayType).toBe("result")
+      const okResult = methodMeta.resolve({ Ok: BigInt(12345) })
+      expect(okResult.results[0].type).toBe("variant")
+      if (okResult.results[0].type === "variant") {
+        expect(okResult.results[0].displayType).toBe("result")
       } else {
         throw new Error("Expected variant field")
       }
 
-      const okValue = okResult.results[0].value as {
-        option: string
-        value: { field: ResultField; value: unknown }
-      }
-      expect(okValue.option).toBe("Ok")
-      expect(okValue.value.value).toBe("12345")
+      const okValue = okResult.results[0] as ResolvedNode
+      expect((okValue as any).selected).toBe("Ok")
+      expect(((okValue as any).selectedOption as ResolvedNode).value).toBe(
+        "12345"
+      )
 
       // Test Err case
-      const errResult = methodMeta.generateMetadata({
+      const errResult = methodMeta.resolve({
         Err: "Insufficient funds",
       })
-      const errValue = errResult.results[0].value as {
-        option: string
-        value: { field: ResultField; value: unknown }
-      }
-      expect(errValue.option).toBe("Err")
-      expect(errValue.value.value).toBe("Insufficient funds")
+      const errValue = errResult.results[0] as ResolvedNode
+      expect((errValue as any).selected).toBe("Err")
+      expect(((errValue as any).selectedOption as ResolvedNode).value).toBe(
+        "Insufficient funds"
+      )
     })
 
     it("should generate metadata for optional return value", () => {
@@ -1672,16 +1622,13 @@ describe("ResultFieldVisitor", () => {
       const methodMeta = serviceMeta["findUser"]
 
       // Test with value - Optional is [value]
-      const foundResult = methodMeta.generateMetadata(["Alice"])
-      expect(foundResult.results[0].field.type).toBe("optional")
-      const foundInner = foundResult.results[0].value as {
-        field: ResultField
-        value: unknown
-      }
-      expect(foundInner.value).toBe("Alice")
+      const foundResult = methodMeta.resolve(["Alice"])
+      expect(foundResult.results[0].type).toBe("optional")
+      const foundInner = foundResult.results[0] as OptionalNode
+      expect(foundInner.value?.value).toBe("Alice")
 
       // Test with null - optional is []
-      const notFoundResult = methodMeta.generateMetadata([])
+      const notFoundResult = methodMeta.resolve([])
       expect(notFoundResult.results[0].value).toBe(null)
     })
 
@@ -1695,17 +1642,15 @@ describe("ResultFieldVisitor", () => {
       )
       const methodMeta = serviceMeta["getItems"]
 
-      const result = methodMeta.generateMetadata(["item1", "item2", "item3"])
+      const result = methodMeta.resolve(["item1", "item2", "item3"])
 
-      expect(result.results[0].field.type).toBe("vector")
-      const vecValue = result.results[0].value as Array<{
-        field: ResultField
-        value: unknown
-      }>
-      expect(vecValue).toHaveLength(3)
-      expect(vecValue[0].value).toBe("item1")
-      expect(vecValue[1].value).toBe("item2")
-      expect(vecValue[2].value).toBe("item3")
+      expect(result.results[0].type).toBe("vector")
+      const vecNode = result.results[0] as ResolvedNode
+      const vecItems = (vecNode as any).items as ResolvedNode[]
+      expect(vecItems).toHaveLength(3)
+      expect(vecItems[0].value).toBe("item1")
+      expect(vecItems[1].value).toBe("item2")
+      expect(vecItems[2].value).toBe("item3")
     })
 
     it("should generate metadata for update function", () => {
@@ -1721,7 +1666,7 @@ describe("ResultFieldVisitor", () => {
       expect(methodMeta.functionType).toBe("update")
 
       const rawData = [true]
-      const result = methodMeta.generateMetadata(rawData[0])
+      const result = methodMeta.resolve(rawData[0])
 
       expect(result.functionType).toBe("update")
       expect(result.functionName).toBe("setName")
@@ -1754,7 +1699,7 @@ describe("ResultFieldVisitor", () => {
       const methodMeta = serviceMeta["icrc1_transfer"]
 
       // Test successful transfer
-      const successResult = methodMeta.generateMetadata({ Ok: BigInt(1000) })
+      const successResult = methodMeta.resolve({ Ok: BigInt(1000) })
       console.log(
         "🚀 ~ result:",
         JSON.stringify(
@@ -1764,28 +1709,24 @@ describe("ResultFieldVisitor", () => {
         )
       )
 
-      const successValue = successResult.results[0].value as {
-        option: string
-        value: { field: ResultField; value: unknown }
-      }
-      expect(successValue.option).toBe("Ok")
-      expect(successValue.value.value).toBe("1000")
+      const successValue = successResult.results[0] as ResolvedNode
+      expect((successValue as any).selected).toBe("Ok")
+      expect(((successValue as any).selectedOption as ResolvedNode).value).toBe(
+        "1000"
+      )
 
       // Test error case
-      const errorResult = methodMeta.generateMetadata({
+      const errorResult = methodMeta.resolve({
         Err: { InsufficientFunds: { balance: BigInt(50) } },
       })
-      const errorValue = errorResult.results[0].value as {
-        option: string
-        value: { field: ResultField; value: unknown }
-      }
-      expect(errorValue.option).toBe("Err")
+      const errorValue = errorResult.results[0] as ResolvedNode
+      expect((errorValue as any).selected).toBe("Err")
 
-      const val = errorValue.value.value
-      if (typeof val !== "object" || val === null || !("option" in val)) {
+      const val = (errorValue as any).selectedOption as ResolvedNode
+      if (typeof val !== "object" || val === null || !("selected" in val)) {
         throw new Error("Expected variant value object")
       }
-      expect(val.option).toBe("InsufficientFunds")
+      expect((val as any).selected).toBe("InsufficientFunds")
     })
 
     it("should handle empty return", () => {
@@ -1800,16 +1741,16 @@ describe("ResultFieldVisitor", () => {
 
       expect(methodMeta.returnCount).toBe(0)
 
-      const result = methodMeta.generateMetadata([])
+      const result = methodMeta.resolve([])
       expect(result.results).toHaveLength(0)
     })
   })
 
   // ════════════════════════════════════════════════════════════════════════════
-  // generateMetadataWithRaw() Method Tests
+  // resolve() Method Tests
   // ════════════════════════════════════════════════════════════════════════════
 
-  describe("generateMetadataWithRaw() Method", () => {
+  describe("resolve() Method", () => {
     it("should include both raw and display values for single return", () => {
       const service = IDL.Service({
         getBalance: IDL.Func([], [IDL.Nat], ["query"]),
@@ -1823,7 +1764,7 @@ describe("ResultFieldVisitor", () => {
       // Simulate raw BigInt and display string
       const rawData = [BigInt(1000000)]
 
-      const result = methodMeta.generateMetadata(rawData[0])
+      const result = methodMeta.resolve(rawData[0])
 
       expect(result.functionName).toBe("getBalance")
       expect(result.functionType).toBe("query")
@@ -1831,7 +1772,7 @@ describe("ResultFieldVisitor", () => {
       expect(result.results[0].raw).toBe(BigInt(1000000))
       expect(result.results[0].value).toBe("1000000")
       expect(result.results[0].raw).toBe(BigInt(1000000))
-      expect(result.results[0].field.type).toBe("number")
+      expect(result.results[0].type).toBe("number")
     })
 
     it("should include both raw and display values for multiple returns", () => {
@@ -1847,14 +1788,14 @@ describe("ResultFieldVisitor", () => {
       // Use BigInt with string to safe safe integer
       const rawData = [BigInt("9007199254740993"), "active", true]
 
-      const result = methodMeta.generateMetadata(rawData)
+      const result = methodMeta.resolve(rawData)
 
       expect(result.results).toHaveLength(3)
 
       // nat64 → string display, BigInt raw
       expect(result.results[0].value).toBe("9007199254740993")
       expect(result.results[0].raw).toBe(BigInt("9007199254740993"))
-      expect(result.results[0].field.candidType).toBe("nat64")
+      expect(result.results[0].candidType).toBe("nat64")
 
       // text → same for both
       expect(result.results[1].value).toBe("active")
@@ -1880,21 +1821,18 @@ describe("ResultFieldVisitor", () => {
       const methodMeta = serviceMeta["getUser"]
 
       const rawData = [{ name: "Alice", balance: BigInt(500) }]
-      const result = methodMeta.generateMetadata(rawData[0])
+      const result = methodMeta.resolve(rawData[0])
 
       expect(result.results[0].raw).toEqual({
         name: "Alice",
         balance: BigInt(500),
       })
 
-      const recordValue = result.results[0].value
-      if (typeof recordValue !== "object" || recordValue === null) {
-        throw new Error("Expected record value object")
+      const recordNode = result.results[0] as RecordNode
+      if (recordNode.type !== "record") {
+        throw new Error("Expected record node")
       }
-      const val = recordValue as Record<
-        string,
-        { field: ResultField; value: unknown }
-      >
+      const val = recordNode.fields as Record<string, ResolvedNode>
       expect(val.name.value).toBe("Alice")
       expect(val.balance.value).toBe("500")
     })
@@ -1916,20 +1854,13 @@ describe("ResultFieldVisitor", () => {
       // Test Ok case with raw BigInt
       const rawData = [{ Ok: BigInt(12345) }]
 
-      const result = methodMeta.generateMetadata(rawData[0])
+      const result = methodMeta.resolve(rawData[0])
 
       expect(result.results[0].raw).toEqual({ Ok: BigInt(12345) })
 
-      const variantValue = result.results[0].value as any
-      if (
-        typeof variantValue !== "object" ||
-        variantValue === null ||
-        !("option" in variantValue)
-      ) {
-        throw new Error("Expected variant value object")
-      }
-      expect(variantValue.option).toBe("Ok")
-      const innerVal = variantValue.value
+      const variantValue = result.results[0] as ResolvedNode
+      expect((variantValue as any).selected).toBe("Ok")
+      const innerVal = (variantValue as any).selectedOption as ResolvedNode
       expect(innerVal.value).toBe("12345")
     })
 
@@ -1948,11 +1879,11 @@ describe("ResultFieldVisitor", () => {
       const principal = Principal.fromText("aaaaa-aa")
       const rawData = [principal]
 
-      const result = methodMeta.generateMetadata(rawData[0])
+      const result = methodMeta.resolve(rawData[0])
 
       expect(result.results[0].value).toBe("aaaaa-aa")
       expect(result.results[0].raw).toBe(principal)
-      expect(result.results[0].field.type).toBe("principal")
+      expect(result.results[0].type).toBe("principal")
     })
 
     it("should handle vector with raw and display values", () => {
@@ -1967,12 +1898,10 @@ describe("ResultFieldVisitor", () => {
 
       const rawData = [[BigInt(100), BigInt(200), BigInt(300)]]
 
-      const result = methodMeta.generateMetadata(rawData[0])
+      const result = methodMeta.resolve(rawData[0])
 
-      const vecValue = result.results[0].value
-      if (!Array.isArray(vecValue)) {
-        throw new Error("Expected vector value array")
-      }
+      const vecNode = result.results[0] as ResolvedNode
+      const vecValue = (vecNode as any).items as ResolvedNode[]
       expect(vecValue).toHaveLength(3)
       expect(vecValue[0].value).toBe("100")
       expect(vecValue[1].value).toBe("200")
@@ -1992,7 +1921,7 @@ describe("ResultFieldVisitor", () => {
       // Test with value - Optional is [value]
       const rawDataWithValue = [[BigInt(999)]]
 
-      const resultWithValue = methodMeta.generateMetadata(rawDataWithValue[0])
+      const resultWithValue = methodMeta.resolve(rawDataWithValue[0])
 
       expect(resultWithValue.results[0].raw).toEqual([BigInt(999)])
       const innerValue = resultWithValue.results[0].value
@@ -2008,7 +1937,7 @@ describe("ResultFieldVisitor", () => {
       // Test with null - Optional is []
       const rawDataNull = [[]]
 
-      const resultNull = methodMeta.generateMetadata(rawDataNull[0])
+      const resultNull = methodMeta.resolve(rawDataNull[0])
       expect(resultNull.results[0].raw).toEqual([])
       expect(resultNull.results[0].value).toBe(null)
     })
@@ -2023,7 +1952,7 @@ describe("ResultFieldVisitor", () => {
       )
       const methodMeta = serviceMeta["doNothing"]
 
-      const result = methodMeta.generateMetadata([])
+      const result = methodMeta.resolve([])
 
       expect(result.results).toHaveLength(0)
     })