Atlas on type causing refmt stack overflow

block-atlas.go

var blockAtlasEntry = atlas.BuildEntry(Block{}).Transform().
	TransformMarshal(func(liveForm reflect.Value) (serialForm reflect.Value, err error) {
		return StructToTuple(liveForm)
	}, reflect.TypeOf([]interface{}{})).
	TransformUnmarshal(func(serialForm reflect.Value) (liveForm reflect.Value, err error) {
		return TupleToStruct(serialForm, reflect.TypeOf(Block{}))
	}, reflect.TypeOf(Block{})).
	Complete()

tuple-struct-conv.go

// StructToTuple Converts any struct value to an []interface{}{} value where the ith slice
// element is the ith public field.
func StructToTuple(val reflect.Value) (reflect.Value, error) {
	if val.Kind() != reflect.Struct {
		return reflect.ValueOf(nil), fmt.Errorf("struct to tuple expects struct")
	}
	n := val.NumField()
	tuple := make([]interface{}, 0)
	for i := 0; i < n; i++ {
		f := val.Field(i)
		if f.CanInterface() { // only exported fields
			tuple = append(tuple, f.Interface())
		}
	}
	return reflect.ValueOf(tuple), nil
}

// TupleToStruct Converts an []interface{}{} value to a struct value where the ith public 
// field is set to the ith slice element.
func TupleToStruct(tupleVal reflect.Value, structType reflect.Type) (reflect.Value, error) {
	structPtrVal := reflect.New(structType)
	structVal := structPtrVal.Elem()
	if structVal.Kind() != reflect.Struct {
		return reflect.ValueOf(nil), fmt.Errorf("TupleToStruct expects struct type")
	}
	if tupleVal.Type() != reflect.TypeOf([]interface{}{}) {
		return reflect.ValueOf(nil), fmt.Errorf("TupleToStruct expects []interface{} value")

	}
	n := structVal.NumField()
	j := 0 // total tuple values consumed
	for i := 0; i < n; i++ {
		f := structVal.Field(i)
		if f.CanInterface() { // only exported fields
			tupleI := tupleVal.Index(j)
			f.Set(tupleI.Elem())
			j++
		}
	}
	return structVal, nil
}