@ic-reactor/candid 3.0.14-beta.0 → 3.0.14-beta.2

package/src/visitor/arguments/helpers.ts

@@ -1,5 +1,5 @@
 import {
-  ArgumentFieldType,
+  VisitorDataType,
   CompoundField,
   FieldNode,
   FieldByType,
@@ -9,12 +9,16 @@ import {
   VariantField,
 } from "./types"
 
+// ════════════════════════════════════════════════════════════════════════════
+// Type Guards
+// ════════════════════════════════════════════════════════════════════════════
+
 /**
  * Type guard for checking specific field types.
  *
  * @example
  * ```tsx
- * function FieldInput({ field }: { field: Field }) {
+ * function FieldInput({ field }: { field: FieldNode }) {
  *   if (isFieldType(field, 'record')) {
  *     // field is now typed as RecordField
  *     return <RecordInput field={field} />
@@ -27,14 +31,17 @@ import {
  * }
  * ```
  */
-export function isFieldType<T extends ArgumentFieldType>(
+export function isFieldType<T extends VisitorDataType>(
   field: FieldNode,
   type: T
 ): field is FieldByType<T> {
   return field.type === type
 }
 
-/** Check if a field is a compound type (contains other fields) */
+/**
+ * Check if a field is a compound type (contains other fields).
+ * Compound types: record, variant, tuple, optional, vector, recursive
+ */
 export function isCompoundField(field: FieldNode): field is CompoundField {
   return [
     "record",
@@ -46,16 +53,38 @@ export function isCompoundField(field: FieldNode): field is CompoundField {
   ].includes(field.type)
 }
 
-/** Check if a field is a primitive type */
+/**
+ * Check if a field is a primitive type.
+ * Primitive types: principal, number, text, boolean, null
+ */
 export function isPrimitiveField(field: FieldNode): field is PrimitiveField {
   return ["principal", "number", "text", "boolean", "null"].includes(field.type)
 }
 
-/** Check if a field has children (for iteration) */
+/**
+ * Check if a field has child fields array (for iteration).
+ * Applies to: record (fields), tuple (fields)
+ */
 export function hasChildFields(
   field: FieldNode
-): field is RecordField | VariantField | TupleField {
-  return "fields" in field && Array.isArray((field as RecordField).fields)
+): field is RecordField | TupleField {
+  return (
+    (field.type === "record" || field.type === "tuple") &&
+    "fields" in field &&
+    Array.isArray((field as RecordField).fields)
+  )
+}
+
+/**
+ * Check if a field has variant options (for iteration).
+ * Applies to: variant (options)
+ */
+export function hasOptions(field: FieldNode): field is VariantField {
+  return (
+    field.type === "variant" &&
+    "options" in field &&
+    Array.isArray((field as VariantField).options)
+  )
 }
 
 // ════════════════════════════════════════════════════════════════════════════
@@ -72,6 +101,7 @@ export function hasChildFields(
  * formatLabel("_0_")           // "Item 0"
  * formatLabel("created_at")    // "Created At"
  * formatLabel("userAddress")   // "User Address"
+ * formatLabel("__ret0")        // "Result 0"
  * ```
  */
 export function formatLabel(label: string): string {
@@ -81,12 +111,24 @@ export function formatLabel(label: string): string {
     return `Arg ${num}`
   }
 
+  // Handle return labels: __ret0 -> Result 0
+  if (label.startsWith("__ret")) {
+    const num = label.slice(5)
+    return `Result ${num}`
+  }
+
   // Handle tuple index labels: _0_ -> Item 0
   if (/^_\d+_$/.test(label)) {
     const num = label.slice(1, -1)
     return `Item ${num}`
   }
 
+  // Handle simple index labels: _0 -> Item 0
+  if (/^_\d+$/.test(label)) {
+    const num = label.slice(1)
+    return `Item ${num}`
+  }
+
   // Handle item labels for vectors: label_item -> Item
   if (label.endsWith("_item")) {
     return "Item"

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

@@ -148,8 +148,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.type).toBe("record")
       expect(field.label).toBe("person")
       expect(field.fields).toHaveLength(2)
-      expect(field.fieldMap.has("name")).toBe(true)
-      expect(field.fieldMap.has("age")).toBe(true)
+      expect(field.fields.some((f) => f.label === "name")).toBe(true)
+      expect(field.fields.some((f) => f.label === "age")).toBe(true)
 
       const nameField = field.fields.find((f) => f.label === "name")
       if (!nameField || nameField.type !== "text") {
@@ -289,14 +289,14 @@ describe("ArgumentFieldVisitor", () => {
 
       expect(field.type).toBe("variant")
       expect(field.label).toBe("status")
-      expect(field.options).toEqual(["Inactive", "Active", "Pending"])
+      expect(field.options.map((f) => f.label)).toEqual([
+        "Inactive",
+        "Active",
+        "Pending",
+      ])
       expect(field.defaultOption).toBe("Inactive")
-      expect(field.fields).toHaveLength(3)
-      expect(field.optionMap.has("Active")).toBe(true)
-
-      field.fields.forEach((f) => {
-        expect(f.type).toBe("null")
-      })
+      expect(field.options).toHaveLength(3)
+      expect(field.options.some((f) => f.label === "Active")).toBe(true)
 
       // Test getOptionDefault helper
       expect(field.getOptionDefault("Active")).toEqual({ _type: "Active" })
@@ -338,9 +338,13 @@ describe("ArgumentFieldVisitor", () => {
       )
 
       expect(field.type).toBe("variant")
-      expect(field.options).toEqual(["Approve", "Burn", "Transfer"]) // Sorted order
+      expect(field.options.map((f) => f.label)).toEqual([
+        "Approve",
+        "Burn",
+        "Transfer",
+      ]) // Sorted order
 
-      const transferField = field.fields.find(
+      const transferField = field.options.find(
         (f) => f.label === "Transfer"
       ) as RecordField
       if (!transferField || transferField.type !== "record") {
@@ -349,7 +353,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(transferField.type).toBe("record")
       expect(transferField.fields).toHaveLength(2)
 
-      const burnField = field.fields.find((f) => f.label === "Burn")
+      const burnField = field.options.find((f) => f.label === "Burn")
       if (!burnField || burnField.type !== "text") {
         throw new Error("Burn field not found or not text")
       }
@@ -371,16 +375,16 @@ describe("ArgumentFieldVisitor", () => {
       )
 
       expect(field.type).toBe("variant")
-      expect(field.options).toContain("Ok")
-      expect(field.options).toContain("Err")
+      expect(field.options.some((f) => f.label === "Ok")).toBe(true)
+      expect(field.options.some((f) => f.label === "Err")).toBe(true)
 
-      const okField = field.fields.find((f) => f.label === "Ok")
+      const okField = field.options.find((f) => f.label === "Ok")
       if (!okField || okField.type !== "text") {
         throw new Error("Ok field not found or not text")
       }
       expect(okField.type).toBe("text")
 
-      const errField = field.fields.find((f) => f.label === "Err")
+      const errField = field.options.find((f) => f.label === "Err")
       if (!errField || errField.type !== "text") {
         throw new Error("Err field not found or not text")
       }
@@ -567,8 +571,8 @@ describe("ArgumentFieldVisitor", () => {
         throw new Error("Extracted field is not variant")
       }
       expect(extracted.type).toBe("variant")
-      expect(extracted.options).toContain("Leaf")
-      expect(extracted.options).toContain("Node")
+      expect(extracted.options.some((f) => f.label === "Leaf")).toBe(true)
+      expect(extracted.options.some((f) => f.label === "Node")).toBe(true)
     })
 
     it("should handle recursive linked list", () => {
@@ -602,9 +606,9 @@ describe("ArgumentFieldVisitor", () => {
         throw new Error("Extracted field is not variant")
       }
       expect(extracted.type).toBe("variant")
-      expect(extracted.options).toEqual(["Nil", "Cons"])
+      expect(extracted.options.map((f) => f.label)).toEqual(["Nil", "Cons"])
 
-      const consField = extracted.fields.find(
+      const consField = extracted.options.find(
         (f) => f.label === "Cons"
       ) as RecordField
       if (!consField || consField.type !== "record") {
@@ -626,11 +630,11 @@ describe("ArgumentFieldVisitor", () => {
 
       expect(meta.functionType).toBe("query")
       expect(meta.functionName).toBe("lookup")
-      expect(meta.fields).toHaveLength(1)
-      expect(meta.fields[0].type).toBe("text")
-      expect(meta.defaultValues).toEqual([""])
+      expect(meta.args).toHaveLength(1)
+      expect(meta.args[0].type).toBe("text")
+      expect(meta.defaults).toEqual([""])
       expect(meta.argCount).toBe(1)
-      expect(meta.isNoArgs).toBe(false)
+      expect(meta.isEmpty).toBe(false)
     })
 
     it("should handle update function", () => {
@@ -653,10 +657,10 @@ describe("ArgumentFieldVisitor", () => {
 
       expect(meta.functionType).toBe("update")
       expect(meta.functionName).toBe("transfer")
-      expect(meta.fields).toHaveLength(1)
-      expect(meta.fields[0].type).toBe("record")
+      expect(meta.args).toHaveLength(1)
+      expect(meta.args[0].type).toBe("record")
 
-      const recordField = meta.fields[0] as RecordField
+      const recordField = meta.args[0] as RecordField
       if (recordField.type !== "record") {
         throw new Error("Expected record field")
       }
@@ -671,10 +675,10 @@ describe("ArgumentFieldVisitor", () => {
       )
       const meta = visitor.visitFunc(funcType, "authorize")
 
-      expect(meta.fields).toHaveLength(3)
-      expect(meta.fields[0].type).toBe("principal")
-      expect(meta.fields[1].type).toBe("text")
-      expect(meta.fields[2].type).toBe("optional")
+      expect(meta.args).toHaveLength(3)
+      expect(meta.args[0].type).toBe("principal")
+      expect(meta.args[1].type).toBe("text")
+      expect(meta.args[2].type).toBe("optional")
       expect(meta.argCount).toBe(3)
     })
 
@@ -683,10 +687,10 @@ describe("ArgumentFieldVisitor", () => {
       const meta = visitor.visitFunc(funcType, "getBalance")
 
       expect(meta.functionType).toBe("query")
-      expect(meta.fields).toHaveLength(0)
-      expect(meta.defaultValues).toEqual([])
+      expect(meta.args).toHaveLength(0)
+      expect(meta.defaults).toEqual([])
       expect(meta.argCount).toBe(0)
-      expect(meta.isNoArgs).toBe(true)
+      expect(meta.isEmpty).toBe(true)
     })
   })
 
@@ -730,20 +734,20 @@ describe("ArgumentFieldVisitor", () => {
       // Check get_balance
       const getBalanceMeta = serviceMeta["get_balance"]
       expect(getBalanceMeta.functionType).toBe("query")
-      expect(getBalanceMeta.fields).toHaveLength(1)
-      expect(getBalanceMeta.fields[0].type).toBe("principal")
+      expect(getBalanceMeta.args).toHaveLength(1)
+      expect(getBalanceMeta.args[0].type).toBe("principal")
 
       // Check transfer
       const transferMeta = serviceMeta["transfer"]
       expect(transferMeta.functionType).toBe("update")
-      expect(transferMeta.fields).toHaveLength(1)
-      expect(transferMeta.fields[0].type).toBe("record")
+      expect(transferMeta.args).toHaveLength(1)
+      expect(transferMeta.args[0].type).toBe("record")
 
       // Check get_metadata
       const getMetadataMeta = serviceMeta["get_metadata"]
       expect(getMetadataMeta.functionType).toBe("query")
-      expect(getMetadataMeta.fields).toHaveLength(0)
-      expect(getMetadataMeta.isNoArgs).toBe(true)
+      expect(getMetadataMeta.args).toHaveLength(0)
+      expect(getMetadataMeta.isEmpty).toBe(true)
     })
   })
 
@@ -768,7 +772,7 @@ describe("ArgumentFieldVisitor", () => {
       )
       const meta = visitor.visitFunc(funcType, "updateUser")
 
-      const argRecord = meta.fields[0] as RecordField
+      const argRecord = meta.args[0] as RecordField
       if (argRecord.type !== "record") {
         throw new Error("Expected record field")
       }
@@ -799,7 +803,7 @@ describe("ArgumentFieldVisitor", () => {
       const funcType = IDL.Func([IDL.Vec(IDL.Text)], [], [])
       const meta = visitor.visitFunc(funcType, "addTags")
 
-      const vecField = meta.fields[0] as VectorField
+      const vecField = meta.args[0] as VectorField
       if (vecField.type !== "vector") {
         throw new Error("Expected vector field")
       }
@@ -919,12 +923,16 @@ describe("ArgumentFieldVisitor", () => {
       )
 
       expect(field.type).toBe("variant")
-      expect(field.options).toContain("Motion")
-      expect(field.options).toContain("TransferSnsTreasuryFunds")
-      expect(field.options).toContain("UpgradeSnsControlledCanister")
+      expect(field.options.some((f) => f.label === "Motion")).toBe(true)
+      expect(
+        field.options.some((f) => f.label === "TransferSnsTreasuryFunds")
+      ).toBe(true)
+      expect(
+        field.options.some((f) => f.label === "UpgradeSnsControlledCanister")
+      ).toBe(true)
 
       // Check Motion variant
-      const motionField = field.fields.find(
+      const motionField = field.options.find(
         (f) => f.label === "Motion"
       ) as RecordField
       if (!motionField || motionField.type !== "record") {
@@ -934,7 +942,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(motionField.fields).toHaveLength(1)
 
       // Check TransferSnsTreasuryFunds variant
-      const transferField = field.fields.find(
+      const transferField = field.options.find(
         (f) => f.label === "TransferSnsTreasuryFunds"
       ) as RecordField
       if (!transferField || transferField.type !== "record") {
@@ -1003,8 +1011,8 @@ describe("ArgumentFieldVisitor", () => {
       const funcType = IDL.Func([IDL.Text, IDL.Nat], [], [])
       const meta = visitor.visitFunc(funcType, "test")
 
-      expect(meta.fields[0].displayLabel).toBe("Arg 0")
-      expect(meta.fields[1].displayLabel).toBe("Arg 1")
+      expect(meta.args[0].displayLabel).toBe("Arg 0")
+      expect(meta.args[1].displayLabel).toBe("Arg 1")
     })
 
     it("should format tuple index labels correctly", () => {
@@ -1223,14 +1231,14 @@ describe("ArgumentFieldVisitor", () => {
         "action"
       )
 
-      const transferField = field.getField("Transfer")
+      const transferField = field.getOption("Transfer")
       expect(transferField.type).toBe("record")
 
-      const burnField = field.getField("Burn")
+      const burnField = field.getOption("Burn")
       expect(burnField.type).toBe("text") // nat is rendered as text for large numbers
     })
 
-    it("getSelectedOption should return the selected option from a value", () => {
+    it("getSelectedKey should return the selected key from a value", () => {
       const variantType = IDL.Variant({ A: IDL.Null, B: IDL.Text, C: IDL.Nat })
       const field = visitor.visitVariant(
         variantType,
@@ -1242,11 +1250,11 @@ describe("ArgumentFieldVisitor", () => {
         "choice"
       )
 
-      expect(field.getSelectedOption({ A: null })).toBe("A")
-      expect(field.getSelectedOption({ B: "hello" })).toBe("B")
-      expect(field.getSelectedOption({ C: "100" })).toBe("C")
+      expect(field.getSelectedKey({ A: null })).toBe("A")
+      expect(field.getSelectedKey({ B: "hello" })).toBe("B")
+      expect(field.getSelectedKey({ C: "100" })).toBe("C")
       // Falls back to default option for unknown values
-      expect(field.getSelectedOption({})).toBe("A")
+      expect(field.getSelectedKey({})).toBe("A")
     })
 
     it("getSelectedField should return the field for the selected option", () => {
@@ -1263,10 +1271,10 @@ describe("ArgumentFieldVisitor", () => {
         "result"
       )
 
-      const okField = field.getSelectedField({ Ok: "100" })
+      const okField = field.getSelectedOption({ Ok: "100" })
       expect(okField.label).toBe("Ok")
 
-      const errField = field.getSelectedField({ Err: "error" })
+      const errField = field.getSelectedOption({ Err: "error" })
       expect(errField.label).toBe("Err")
     })
   })
@@ -1304,7 +1312,7 @@ describe("ArgumentFieldVisitor", () => {
     it("should create item field with correct index in name path", () => {
       const funcType = IDL.Func([IDL.Vec(IDL.Text)], [], [])
       const meta = visitor.visitFunc(funcType, "addItems")
-      const vecField = meta.fields[0] as VectorField
+      const vecField = meta.args[0] as VectorField
 
       const item0 = vecField.createItemField(0)
       expect(item0.name).toBe("[0][0]")
@@ -1320,7 +1328,7 @@ describe("ArgumentFieldVisitor", () => {
         []
       )
       const meta = visitor.visitFunc(funcType, "addItems")
-      const vecField = meta.fields[0] as VectorField
+      const vecField = meta.args[0] as VectorField
 
       const item = vecField.createItemField(3, { label: "Person 3" })
       expect(item.label).toBe("Person 3")
@@ -1330,7 +1338,7 @@ describe("ArgumentFieldVisitor", () => {
     it("should use default label when not provided", () => {
       const funcType = IDL.Func([IDL.Vec(IDL.Text)], [], [])
       const meta = visitor.visitFunc(funcType, "addTags")
-      const vecField = meta.fields[0] as VectorField
+      const vecField = meta.args[0] as VectorField
 
       const item = vecField.createItemField(2)
       expect(item.label).toBe("Item 2")
@@ -1392,4 +1400,40 @@ describe("ArgumentFieldVisitor", () => {
       }
     })
   })
+
+  // ════════════════════════════════════════════════════════════════════════
+  // Format Detection
+  // ════════════════════════════════════════════════════════════════════════
+
+  describe("Format Detection", () => {
+    it("should NOT detect eth format for method_name", () => {
+      const field = visitor.visitText(IDL.Text, "method_name")
+      expect(field.format).toBe("plain")
+    })
+
+    it("should detect eth format for my_eth_address", () => {
+      const field = visitor.visitText(IDL.Text, "my_eth_address")
+      expect(field.format).toBe("eth")
+    })
+
+    it("should detect eth format for myEthAddress", () => {
+      const field = visitor.visitText(IDL.Text, "myEthAddress")
+      expect(field.format).toBe("eth")
+    })
+
+    it("should detect eth format for ethereum", () => {
+      const field = visitor.visitText(IDL.Text, "ethereum")
+      expect(field.format).toBe("eth")
+    })
+
+    it("should detect btc format for bitcoin_address", () => {
+      const field = visitor.visitText(IDL.Text, "bitcoin_address")
+      expect(field.format).toBe("btc")
+    })
+
+    it("should NOT detect btc format for debt", () => {
+      const field = visitor.visitText(IDL.Text, "debt")
+      expect(field.format).toBe("plain")
+    })
+  })
 })

package/src/visitor/arguments/index.ts

@@ -1,5 +1,6 @@
 import { isQuery } from "../helpers"
 import { checkTextFormat, checkNumberFormat } from "../constants"
+import { MetadataError } from "./types"
 import type {
   FieldNode,
   RecordField,
@@ -233,13 +234,13 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
     const functionType = isQuery(t) ? "query" : "update"
     const argCount = t.argTypes.length
 
-    const fields = t.argTypes.map((arg, index) => {
+    const args = t.argTypes.map((arg, index) => {
       return this.withName(`[${index}]`, () =>
         arg.accept(this, `__arg${index}`)
       ) as FieldNode
     })
 
-    const defaultValues = fields.map((field) => field.defaultValue)
+    const defaults = args.map((field) => field.defaultValue)
 
     // Handle empty args case for schema
     // For no-arg functions, use an empty array schema
@@ -250,7 +251,7 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
             [z.ZodTypeAny, ...z.ZodTypeAny[]]
           >)
         : z.tuple(
-            fields.map((field) => field.schema) as [
+            args.map((field) => field.schema) as [
               z.ZodTypeAny,
               ...z.ZodTypeAny[],
             ]
@@ -259,11 +260,11 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
     return {
       functionType,
       functionName,
-      fields,
-      defaultValues: defaultValues,
+      args,
+      defaults,
       schema,
       argCount,
-      isNoArgs: argCount === 0,
+      isEmpty: argCount === 0,
     }
   }
 
@@ -278,7 +279,6 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
   ): RecordField {
     const name = this.currentName()
     const fields: FieldNode[] = []
-    const fieldMap = new Map<string, FieldNode>()
     const defaultValue: Record<string, unknown> = {}
     const schemaShape: Record<string, z.ZodTypeAny> = {}
 
@@ -288,7 +288,6 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       ) as FieldNode
 
       fields.push(field)
-      fieldMap.set(key, field)
       defaultValue[key] = field.defaultValue
       schemaShape[key] = field.schema
     }
@@ -303,7 +302,6 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       component: "record-container",
       renderHint: COMPOUND_RENDER_HINT,
       fields,
-      fieldMap,
       defaultValue,
       schema,
       candidType: "record",
@@ -316,9 +314,7 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
     label: string
   ): VariantField {
     const name = this.currentName()
-    const fields: FieldNode[] = []
-    const options: string[] = []
-    const optionMap = new Map<string, FieldNode>()
+    const options: FieldNode[] = []
     const variantSchemas: z.ZodTypeAny[] = []
 
     for (const [key, type] of fields_) {
@@ -326,9 +322,7 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
         type.accept(this, key)
       ) as FieldNode
 
-      fields.push(field)
-      options.push(key)
-      optionMap.set(key, field)
+      options.push(field)
 
       if (field.type === "null") {
         variantSchemas.push(z.object({ _type: z.literal(key) }))
@@ -342,24 +336,28 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       }
     }
 
-    const defaultOption = options[0]
-    const firstField = fields[0]
+    const firstOption = options[0]
+    const defaultOption = firstOption.label
 
     const defaultValue =
-      firstField.type === "null"
+      firstOption.type === "null"
         ? { _type: defaultOption }
         : {
             _type: defaultOption,
-            [defaultOption]: firstField.defaultValue,
+            [defaultOption]: firstOption.defaultValue,
           }
 
-    const schema = z.union(variantSchemas)
+    const schema = z.union(variantSchemas as [z.ZodTypeAny, ...z.ZodTypeAny[]])
 
     // Helper to get default value for any option
     const getOptionDefault = (option: string): Record<string, unknown> => {
-      const optField = optionMap.get(option)
+      const optField = options.find((f) => f.label === option)
       if (!optField) {
-        throw new Error(`Unknown variant option: ${option}`)
+        throw new MetadataError(
+          `Unknown variant option: "${option}". Available: ${options.map((o) => o.label).join(", ")}`,
+          name,
+          "variant"
+        )
       }
       return optField.type === "null"
         ? { _type: option }
@@ -367,27 +365,33 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
     }
 
     // Helper to get field for a specific option
-    const getField = (option: string): FieldNode => {
-      const optField = optionMap.get(option)
+    const getOption = (option: string): FieldNode => {
+      const optField = options.find((f) => f.label === option)
       if (!optField) {
-        throw new Error(`Unknown variant option: ${option}`)
+        throw new MetadataError(
+          `Unknown variant option: "${option}". Available: ${options.map((o) => o.label).join(", ")}`,
+          name,
+          "variant"
+        )
       }
       return optField
     }
 
-    // Helper to get currently selected option from a value
-    const getSelectedOption = (value: Record<string, unknown>): string => {
+    // Helper to get currently selected option key from a value
+    const getSelectedKey = (value: Record<string, unknown>): string => {
       if (value._type && typeof value._type === "string") {
         return value._type
       }
-      const validKeys = Object.keys(value).filter((k) => options.includes(k))
+      const validKeys = Object.keys(value).filter((k) =>
+        options.some((f) => f.label === k)
+      )
       return validKeys[0] ?? defaultOption
     }
 
-    // Helper to get selected field from a value
-    const getSelectedField = (value: Record<string, unknown>): FieldNode => {
-      const selectedOption = getSelectedOption(value)
-      return getField(selectedOption)
+    // Helper to get the field for the currently selected option
+    const getSelectedOption = (value: Record<string, unknown>): FieldNode => {
+      const selectedKey = getSelectedKey(value)
+      return getOption(selectedKey)
     }
 
     return {
@@ -397,16 +401,14 @@ export class FieldVisitor<A = BaseActor> extends IDL.Visitor<
       name,
       component: "variant-select",
       renderHint: COMPOUND_RENDER_HINT,
-      fields,
       options,
       defaultOption,
-      optionMap,
       defaultValue,
       schema,
       getOptionDefault,
-      getField,
+      getOption,
+      getSelectedKey,
       getSelectedOption,
-      getSelectedField,
       candidType: "variant",
     }
   }