@ic-reactor/candid 3.0.8-beta.2 → 3.0.10-beta.0

package/src/visitor/returns/index.ts

@@ -2,25 +2,17 @@ import { isQuery } from "../helpers"
 import { checkTextFormat, checkNumberFormat } from "../constants"
 import { IDL } from "../types"
 import type {
-  ResultField,
-  ResultFieldWithValue,
-  RecordResultField,
-  VariantResultField,
-  TupleResultField,
-  OptionalResultField,
-  VectorResultField,
-  BlobResultField,
-  RecursiveResultField,
-  PrincipalResultField,
-  NumberResultField,
-  TextResultField,
-  BooleanResultField,
-  NullResultField,
-  UnknownResultField,
-  MethodResultMeta,
-  ServiceResultMeta,
+  ResultNode,
+  ResolvedNode,
+  NodeType,
+  MethodMeta,
+  ServiceMeta,
   ResolvedMethodResult,
+  NumberFormat,
+  TextFormat,
 } from "./types"
+
+export * from "./types"
 import { DisplayCodecVisitor } from "@ic-reactor/core"
 import type {
   ActorMethodReturnType,
@@ -31,523 +23,385 @@ import type {
 
 export * from "./types"
 
+// ════════════════════════════════════════════════════════════════════════════
+// Node Factory - Eliminates Boilerplate
+// ════════════════════════════════════════════════════════════════════════════
+
+type Codec = { decode: (v: unknown) => unknown }
+
 /**
- * ResultFieldVisitor generates metadata for displaying method results from Candid IDL types.
- *
- * ## Design Principles
- *
- * 1. **Works with raw IDL types BEFORE transformation** - generates metadata at initialization
- * 2. **No value dependencies** - metadata describes structure, not specific values
- * 3. **Describes display format** - includes hints for how values will appear after transformation
- * 4. **Efficient** - single traversal, reusable metadata
- * 5. **Resolvable** - metadata can be combined with values at runtime via .resolve(val)
- *
- * ## Key Insight: Metadata vs Values
- *
- * The visitor generates a "schema" that describes:
- * - What type each field is in Candid (nat, Principal, opt, etc.)
- * - What it becomes after display transformation (string, null, etc.)
- * - How it should be formatted (timestamp, cycle, hex, etc.)
- *
- * Values are NOT passed during traversal. Instead, the generated schema
- * is used at render time to properly display transformed values.
- *
- * ## Display Transformations (applied by DisplayCodecVisitor)
- *
- * | Candid Type | Display Type | Notes |
- * |-------------|--------------|-------|
- * | nat, int, nat64, int64 | string | BigInt → string |
- * | Principal | string | Principal.toText() |
- * | opt T | T \| null | [value] → value, [] → null |
- * | vec nat8 (blob) | string | Uint8Array → hex string |
- * | variant { Ok, Err } | unwrapped | { Ok: val } → val (or throws on Err) |
- *
- * @example
- * ```typescript
- * const visitor = new ResultFieldVisitor()
- * const serviceMeta = service.accept(visitor, null)
- *
- * // Get method result metadata
- * const methodMeta = serviceMeta["icrc1_balance_of"]
- * // methodMeta.resultFields[0] = {
- * //   type: "number",
- * //   candidType: "nat",
- * //   displayType: "string",
- * //   numberFormat: "normal"
- * // }
- *
- * // At render time, apply to transformed value:
- * const transformedResult = "1000000000" // Already transformed by DisplayCodec
- * renderField(methodMeta.resultFields[0], transformedResult)
- * ```
+ * Creates a primitive node with automatic resolve implementation.
  */
+function primitiveNode<T extends NodeType>(
+  type: T,
+  label: string,
+  candidType: string,
+  displayType: ResultNode["displayType"],
+  codec: Codec,
+  extras: object = {}
+): ResultNode<T> {
+  const node: ResultNode<T> = {
+    type,
+    label,
+    candidType,
+    displayType,
+    ...extras,
+    resolve(data: unknown): ResolvedNode<T> {
+      return {
+        ...node,
+        value: codec.decode(data),
+        raw: data,
+      } as unknown as ResolvedNode<T>
+    },
+  } as unknown as ResultNode<T>
+  return node
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// Simplified Result Field Visitor
+// ════════════════════════════════════════════════════════════════════════════
+
 export class ResultFieldVisitor<A = BaseActor> extends IDL.Visitor<
   string,
-  ResultField | MethodResultMeta<A> | ServiceResultMeta<A>
+  ResultNode | MethodMeta<A> | ServiceMeta<A>
 > {
-  private displayVisitor = new DisplayCodecVisitor()
+  private codec = new DisplayCodecVisitor()
 
-  // ════════════════════════════════════════════════════════════════════════
-  // Service & Function Level
-  // ════════════════════════════════════════════════════════════════════════
+  private getCodec(t: IDL.Type): Codec {
+    return t.accept(this.codec, null) as Codec
+  }
 
-  public visitService(t: IDL.ServiceClass): ServiceResultMeta<A> {
-    const result = {} as ServiceResultMeta<A>
+  // ══════════════════════════════════════════════════════════════════════════
+  // Service & Function
+  // ══════════════════════════════════════════════════════════════════════════
 
-    for (const [functionName, func] of t._fields) {
-      result[functionName as FunctionName<A>] = func.accept(
-        this,
-        functionName
-      ) as MethodResultMeta<A>
+  public visitService(t: IDL.ServiceClass): ServiceMeta<A> {
+    const result = {} as ServiceMeta<A>
+    for (const [name, func] of t._fields) {
+      result[name as FunctionName<A>] = func.accept(this, name) as MethodMeta<A>
     }
-
     return result
   }
 
   public visitFunc(
     t: IDL.FuncClass,
     functionName: FunctionName<A>
-  ): MethodResultMeta<A> {
+  ): MethodMeta<A> {
     const functionType: FunctionType = isQuery(t) ? "query" : "update"
-
-    const resultFields = t.retTypes.map((retType, index) =>
-      retType.accept(this, `__ret${index}`)
-    ) as ResultField[]
-
-    const generateMetadata = (
-      data: ActorMethodReturnType<A[FunctionName<A>]>
-    ): ResolvedMethodResult<A> => {
-      const dataArray: unknown[] =
-        resultFields.length === 0
-          ? []
-          : resultFields.length === 1
-            ? [data]
-            : (data as unknown[])
-
-      const results = resultFields.map((field, index) =>
-        field.resolve(dataArray[index])
-      )
-
-      return {
-        functionType,
-        functionName,
-        results,
-        raw: data,
-      }
-    }
+    const returns = t.retTypes.map((ret, i) =>
+      ret.accept(this, `__ret${i}`)
+    ) as ResultNode[]
 
     return {
       functionType,
       functionName,
-      resultFields,
+      returns,
       returnCount: t.retTypes.length,
-      generateMetadata,
+      resolve: (
+        data: ActorMethodReturnType<A[FunctionName<A>]>
+      ): ResolvedMethodResult<A> => {
+        const dataArray = returns.length <= 1 ? [data] : (data as unknown[])
+        return {
+          functionType,
+          functionName,
+          results: returns.map((node, i) => node.resolve(dataArray[i])),
+          raw: data,
+        }
+      },
     }
   }
 
-  // ════════════════════════════════════════════════════════════════════════
+  // ══════════════════════════════════════════════════════════════════════════
   // Compound Types
-  // ════════════════════════════════════════════════════════════════════════
+  // ══════════════════════════════════════════════════════════════════════════
 
   public visitRecord(
     _t: IDL.RecordClass,
     fields_: Array<[string, IDL.Type]>,
     label: string
-  ): RecordResultField {
-    const fields = fields_.map(
-      ([key, type]) => type.accept(this, key) as ResultField
-    )
+  ): ResultNode<"record"> {
+    const fields: Record<string, ResultNode> = {}
+    for (const [key, type] of fields_) {
+      fields[key] = type.accept(this, key) as ResultNode
+    }
 
-    const field: RecordResultField = {
+    const node: ResultNode<"record"> = {
       type: "record",
       label,
       candidType: "record",
       displayType: "object",
       fields,
-      resolve(value: unknown): ResultFieldWithValue {
-        const record = value as Record<string, unknown> | null | undefined
-        if (record == null) {
-          return { field, value: null, raw: value }
+      resolve(data: unknown): ResolvedNode<"record"> {
+        if (data === null || data === undefined) {
+          throw new Error(`Expected record for field ${label}, but got ${data}`)
         }
-
-        const resolvedFields: Record<string, ResultFieldWithValue> = {}
-        for (const f of fields) {
-          resolvedFields[f.label] = f.resolve(record[f.label])
+        const recordData = data as Record<string, unknown>
+        const resolvedFields: Record<string, ResolvedNode> = {}
+        for (const [key, field] of Object.entries(fields)) {
+          resolvedFields[key] = field.resolve(recordData[key])
         }
-
-        return { field, value: resolvedFields, raw: value }
+        return { ...node, fields: resolvedFields, raw: data }
       },
     }
-    return field
+    return node
   }
 
   public visitVariant(
     _t: IDL.VariantClass,
     fields_: Array<[string, IDL.Type]>,
     label: string
-  ): VariantResultField {
-    const options: string[] = []
-    const optionFields: ResultField[] = []
-
+  ): ResultNode<"variant"> {
+    const selectedOption: Record<string, ResultNode> = {}
     for (const [key, type] of fields_) {
-      options.push(key)
-      optionFields.push(type.accept(this, key) as ResultField)
+      selectedOption[key] = type.accept(this, key) as ResultNode
     }
-
-    // Detect if this is a Result type (has Ok and Err options)
-    const isResult = options.includes("Ok") && options.includes("Err")
-    const displayType = isResult ? "result" : "variant"
-
-    const field: VariantResultField = {
+    const isResult = "Ok" in selectedOption && "Err" in selectedOption
+    const node: ResultNode<"variant"> = {
       type: "variant",
       label,
       candidType: "variant",
-      displayType,
-      options,
-      optionFields,
-      resolve(value: unknown): ResultFieldWithValue {
-        if (value == null) {
-          return { field, value: null, raw: value }
+      displayType: isResult ? "result" : "variant",
+      selectedOption: {} as ResultNode, // placeholder, populated on resolve
+      resolve(data: unknown): ResolvedNode<"variant"> {
+        if (data === null || data === undefined) {
+          throw new Error(
+            `Expected variant for field ${label}, but got ${data}`
+          )
         }
-
-        const variant = value as Record<string, unknown>
-        const optionsInValue = Object.keys(variant)
-        const activeOption = optionsInValue.find((opt) => options.includes(opt))
-
-        if (!activeOption) {
-          return { field, value: null, raw: value }
+        const variantData = data as Record<string, unknown>
+        const selected = Object.keys(variantData)[0]
+        const optionNode = selectedOption[selected]
+        if (!optionNode) {
+          throw new Error(`Option ${selected} not found in variant`)
         }
-
-        const activeValue = variant[activeOption]
-        const optionIndex = options.indexOf(activeOption)
-        const optionField = optionFields[optionIndex]
-
-        const specificField: VariantResultField = {
-          ...field,
-          options,
-          optionFields: [optionField],
-        }
-
         return {
-          field: specificField,
-          value: {
-            option: activeOption,
-            value: optionField?.resolve(activeValue) ?? {
-              field: optionField,
-              value: activeValue,
-              raw: activeValue,
-            },
-          },
-          raw: value,
+          ...node,
+          selected,
+          selectedOption: optionNode.resolve(variantData[selected]),
+          raw: data,
         }
       },
     }
-
-    return field
+    return node
   }
 
   public visitTuple<T extends IDL.Type[]>(
     _t: IDL.TupleClass<T>,
     components: IDL.Type[],
     label: string
-  ): TupleResultField {
-    const fields = components.map(
-      (type, index) => type.accept(this, `_${index}`) as ResultField
+  ): ResultNode<"tuple"> {
+    const items = components.map(
+      (t, i) => t.accept(this, `_${i}`) as ResultNode
     )
 
-    const field: TupleResultField = {
+    const node: ResultNode<"tuple"> = {
       type: "tuple",
       label,
       candidType: "tuple",
       displayType: "array",
-      fields,
-      resolve(value: unknown): ResultFieldWithValue {
-        const tuple = value as unknown[] | null | undefined
-        if (tuple == null) {
-          return { field, value: null, raw: value }
+      items,
+      resolve(data: unknown): ResolvedNode<"tuple"> {
+        if (data === null || data === undefined) {
+          throw new Error(`Expected tuple for field ${label}, but got ${data}`)
+        }
+        const tupleData = data as unknown[]
+        return {
+          ...node,
+          items: items.map((item, i) => item.resolve(tupleData[i])),
+          raw: data,
         }
-
-        const resolvedItems = fields.map((f, index) => f.resolve(tuple[index]))
-        return { field, value: resolvedItems, raw: value }
       },
     }
-
-    return field
+    return node
   }
 
   public visitOpt<T>(
     _t: IDL.OptClass<T>,
     ty: IDL.Type<T>,
     label: string
-  ): OptionalResultField {
-    const innerField = ty.accept(this, label) as ResultField
+  ): ResultNode<"optional"> {
+    const inner = ty.accept(this, label) as ResultNode
 
-    const field: OptionalResultField = {
+    const node: ResultNode<"optional"> = {
       type: "optional",
       label,
       candidType: "opt",
       displayType: "nullable",
-      innerField,
-      resolve(value: unknown): ResultFieldWithValue {
-        const opt = value as [unknown] | [] | null | undefined
-        if (opt == null || opt.length === 0) {
-          return { field, value: null, raw: value }
-        }
-        return { field, value: innerField.resolve(opt[0]), raw: value }
+      value: null, // null until resolved
+      resolve(data: unknown): ResolvedNode<"optional"> {
+        const opt = data as T[]
+        const resolved =
+          Array.isArray(opt) && opt.length > 0 ? inner.resolve(opt[0]) : null
+        return { ...node, value: resolved, raw: data }
       },
     }
-
-    return field
+    return node
   }
 
   public visitVec<T>(
     _t: IDL.VecClass<T>,
     ty: IDL.Type<T>,
     label: string
-  ): VectorResultField | BlobResultField {
-    // Check if it's blob (vec nat8)
+  ): ResultNode<"vector"> | ResultNode<"blob"> {
+    // Blob detection (vec nat8)
     if (ty instanceof IDL.FixedNatClass && ty._bits === 8) {
-      const codec = _t.accept(this.displayVisitor, null) as any
-      const blobField: BlobResultField = {
+      const codec = this.getCodec(_t)
+      const node: ResultNode<"blob"> = {
         type: "blob",
         label,
         candidType: "blob",
-        displayType: "string", // Transformed to hex string
-        displayHint: "hex",
-        resolve(value: unknown): ResultFieldWithValue {
-          return {
-            field: blobField,
-            value: codec.decode(value),
-            raw: value,
-          }
+        displayType: "string",
+        value: "", // empty schema placeholder, populated on resolve
+        resolve(data: unknown): ResolvedNode<"blob"> {
+          return { ...node, value: codec.decode(data) as string, raw: data }
         },
       }
-      return blobField
+      return node
     }
 
-    const itemField = ty.accept(this, "item") as ResultField
+    const itemSchema = ty.accept(this, "item") as ResultNode
 
-    const field: VectorResultField = {
+    const node: ResultNode<"vector"> = {
       type: "vector",
       label,
       candidType: "vec",
       displayType: "array",
-      itemField,
-      resolve(value: unknown): ResultFieldWithValue {
-        const vec = value as unknown[] | null | undefined
-        if (vec == null) {
-          return { field, value: null, raw: value }
+      items: [], // empty schema placeholder, populated on resolve
+      resolve(data: unknown): ResolvedNode<"vector"> {
+        if (data === null || data === undefined) {
+          throw new Error(`Expected vector for field ${label}, but got ${data}`)
+        }
+        const vectorData = data as unknown[]
+        return {
+          ...node,
+          items: vectorData.map((v) => itemSchema.resolve(v)),
+          raw: data,
         }
-
-        const resolvedItems = vec.map((item) => itemField.resolve(item))
-        return { field, value: resolvedItems, raw: value }
       },
     }
-
-    return field
+    return node
   }
 
   public visitRec<T>(
-    t: IDL.RecClass<T>,
+    _t: IDL.RecClass<T>,
     ty: IDL.ConstructType<T>,
     label: string
-  ): RecursiveResultField {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
+  ): ResultNode<"recursive"> {
     const self = this
+    // Lazy extraction to prevent infinite loops
+    let innerSchema: ResultNode | null = null
+    const getInner = () =>
+      (innerSchema ??= ty.accept(self, label) as ResultNode)
 
-    const field: RecursiveResultField = {
+    const node: ResultNode<"recursive"> = {
       type: "recursive",
       label,
       candidType: "rec",
       displayType: "recursive",
-      typeName: t.name,
-      // Lazy extraction to prevent infinite loops
-      extract: () => ty.accept(self, label) as ResultField,
-      resolve(value: unknown): ResultFieldWithValue {
-        // Extract the inner field and resolve with it
-        const innerField = field.extract()
-        return innerField.resolve(value)
+      inner: {} as ResultNode, // placeholder, populated on resolve
+      resolve(data: unknown): ResolvedNode<"recursive"> {
+        return { ...node, inner: getInner().resolve(data), raw: data }
       },
     }
-
-    return field
+    return node
   }
 
-  // ════════════════════════════════════════════════════════════════════════
-  // Primitive Types
-  // ════════════════════════════════════════════════════════════════════════
+  // ══════════════════════════════════════════════════════════════════════════
+  // Primitives - Using Factory
+  // ══════════════════════════════════════════════════════════════════════════
 
   public visitPrincipal(
     t: IDL.PrincipalClass,
     label: string
-  ): PrincipalResultField {
-    const codec = t.accept(this.displayVisitor, null) as any
-    const field: PrincipalResultField = {
-      type: "principal",
+  ): ResultNode<"principal"> {
+    return primitiveNode(
+      "principal",
       label,
-      candidType: "principal",
-      displayType: "string", // Principal.toText()
-      textFormat: checkTextFormat(label),
-      resolve(value: unknown): ResultFieldWithValue {
-        return {
-          field,
-          value: codec.decode(value),
-          raw: value,
-        }
-      },
-    }
-
-    return field
+      "principal",
+      "string",
+      this.getCodec(t),
+      {
+        format: checkTextFormat(label) as TextFormat,
+      }
+    )
   }
 
-  public visitText(t: IDL.TextClass, label: string): TextResultField {
-    const codec = t.accept(this.displayVisitor, null) as any
-    const field: TextResultField = {
-      type: "text",
-      label,
-      candidType: "text",
-      displayType: "string",
-      textFormat: checkTextFormat(label),
-      resolve(value: unknown): ResultFieldWithValue {
-        return { field, value: codec.decode(value), raw: value }
-      },
-    }
-
-    return field
+  public visitText(t: IDL.TextClass, label: string): ResultNode<"text"> {
+    return primitiveNode("text", label, "text", "string", this.getCodec(t), {
+      format: checkTextFormat(label) as TextFormat,
+    })
   }
 
-  public visitBool(t: IDL.BoolClass, label: string): BooleanResultField {
-    const codec = t.accept(this.displayVisitor, null) as any
-    const field: BooleanResultField = {
-      type: "boolean",
-      label,
-      candidType: "bool",
-      displayType: "boolean",
-      resolve(value: unknown): ResultFieldWithValue {
-        return { field, value: codec.decode(value), raw: value }
-      },
-    }
-
-    return field
+  public visitBool(t: IDL.BoolClass, label: string): ResultNode<"boolean"> {
+    return primitiveNode("boolean", label, "bool", "boolean", this.getCodec(t))
   }
 
-  public visitNull(t: IDL.NullClass, label: string): NullResultField {
-    const codec = t.accept(this.displayVisitor, null) as any
-    const field: NullResultField = {
-      type: "null",
-      label,
-      candidType: "null",
-      displayType: "null",
-      resolve(value: unknown): ResultFieldWithValue {
-        return { field, value: codec.decode(value), raw: value }
-      },
-    }
-
-    return field
+  public visitNull(t: IDL.NullClass, label: string): ResultNode<"null"> {
+    return primitiveNode("null", label, "null", "null", this.getCodec(t))
   }
 
-  // Numbers
-  public visitInt(t: IDL.IntClass, label: string): NumberResultField {
-    const codec = t.accept(this.displayVisitor, null) as any
-    const field: NumberResultField = {
-      type: "number",
-      label,
-      candidType: "int",
-      displayType: "string", // BigInt → string
-      numberFormat: checkNumberFormat(label),
-      resolve(value: unknown): ResultFieldWithValue {
-        return { field, value: codec.decode(value), raw: value }
-      },
-    }
-
-    return field
+  public visitInt(t: IDL.IntClass, label: string): ResultNode<"number"> {
+    return primitiveNode("number", label, "int", "string", this.getCodec(t), {
+      format: checkNumberFormat(label) as NumberFormat,
+    })
   }
 
-  public visitNat(t: IDL.NatClass, label: string): NumberResultField {
-    const codec = t.accept(this.displayVisitor, null) as any
-    const field: NumberResultField = {
-      type: "number",
-      label,
-      candidType: "nat",
-      displayType: "string", // BigInt → string
-      numberFormat: checkNumberFormat(label),
-      resolve(value: unknown): ResultFieldWithValue {
-        return { field, value: codec.decode(value), raw: value }
-      },
-    }
-
-    return field
+  public visitNat(t: IDL.NatClass, label: string): ResultNode<"number"> {
+    return primitiveNode("number", label, "nat", "string", this.getCodec(t), {
+      format: checkNumberFormat(label) as NumberFormat,
+    })
   }
 
-  public visitFloat(t: IDL.FloatClass, label: string): NumberResultField {
-    const codec = t.accept(this.displayVisitor, null) as any
-    const field: NumberResultField = {
-      type: "number",
+  public visitFloat(t: IDL.FloatClass, label: string): ResultNode<"number"> {
+    return primitiveNode(
+      "number",
       label,
-      candidType: `float${t._bits}`,
-      displayType: "number", // Floats stay as numbers
-      numberFormat: checkNumberFormat(label),
-      resolve(value: unknown): ResultFieldWithValue {
-        return { field, value: codec.decode(value), raw: value }
-      },
-    }
-
-    return field
+      `float${t._bits}`,
+      "number",
+      this.getCodec(t),
+      {
+        format: checkNumberFormat(label) as NumberFormat,
+      }
+    )
   }
 
-  public visitFixedInt(t: IDL.FixedIntClass, label: string): NumberResultField {
+  public visitFixedInt(
+    t: IDL.FixedIntClass,
+    label: string
+  ): ResultNode<"number"> {
     const bits = t._bits
-    const codec = t.accept(this.displayVisitor, null) as any
-    const field: NumberResultField = {
-      type: "number",
+    return primitiveNode(
+      "number",
       label,
-      candidType: `int${bits}`,
-      displayType: bits <= 32 ? "number" : "string", // int64 → string
-      numberFormat: checkNumberFormat(label),
-      resolve(value: unknown): ResultFieldWithValue {
-        return {
-          field,
-          value: codec.decode(value),
-          raw: value,
-        }
-      },
-    }
-
-    return field
+      `int${bits}`,
+      bits <= 32 ? "number" : "string",
+      this.getCodec(t),
+      {
+        format: checkNumberFormat(label) as NumberFormat,
+      }
+    )
   }
 
-  public visitFixedNat(t: IDL.FixedNatClass, label: string): NumberResultField {
+  public visitFixedNat(
+    t: IDL.FixedNatClass,
+    label: string
+  ): ResultNode<"number"> {
     const bits = t._bits
-    const codec = t.accept(this.displayVisitor, null) as any
-    const field: NumberResultField = {
-      type: "number",
+    return primitiveNode(
+      "number",
       label,
-      candidType: `nat${bits}`,
-      displayType: bits <= 32 ? "number" : "string", // nat64 → string
-      numberFormat: checkNumberFormat(label),
-      resolve(value: unknown): ResultFieldWithValue {
-        return {
-          field,
-          value: codec.decode(value),
-          raw: value,
-        }
-      },
-    }
-
-    return field
+      `nat${bits}`,
+      bits <= 32 ? "number" : "string",
+      this.getCodec(t),
+      {
+        format: checkNumberFormat(label) as NumberFormat,
+      }
+    )
   }
 
-  public visitType<T>(_t: IDL.Type<T>, label: string): UnknownResultField {
-    const field: UnknownResultField = {
-      type: "unknown",
-      label,
-      candidType: "unknown",
-      displayType: "unknown",
-      resolve(value: unknown): ResultFieldWithValue {
-        return { field, value, raw: value }
-      },
-    }
-
-    return field
+  public visitType<T>(_t: IDL.Type<T>, label: string): ResultNode<"unknown"> {
+    return primitiveNode("unknown", label, "unknown", "unknown", {
+      decode: (v) => v,
+    })
   }
 }