fix: decode named byte containers without panicking

decode_hooks.go

@@ -367,7 +367,7 @@ func WeaklyTypedHook(
 			dataType := dataVal.Type()
 			elemKind := dataType.Elem().Kind()
 			if elemKind == reflect.Uint8 {
-				return string(dataVal.Interface().([]uint8)), nil
+				return string(dataVal.Bytes()), nil
 			}
 		case reflect.Uint:
 			return strconv.FormatUint(dataVal.Uint(), 10), nil

decode_hooks_test.go

@@ -824,6 +824,8 @@ func TestStringToIPNetHookFunc(t *testing.T) {
 }
 
 func TestWeaklyTypedHook(t *testing.T) {
+	type octet uint8
+	type bytes []byte
 	var f DecodeHookFunc = WeaklyTypedHook
 
 	strValue := reflect.ValueOf("")
@@ -867,6 +869,18 @@ func TestWeaklyTypedHook(t *testing.T) {
 			"foo", // byte slice converts to string
 			false,
 		},
+		{
+			reflect.ValueOf(bytes("foo")),
+			strValue,
+			"foo",
+			false,
+		},
+		{
+			reflect.ValueOf([]octet{'f', 'o', 'o'}),
+			strValue,
+			"foo",
+			false,
+		},
 
 		{
 			reflect.ValueOf(uint(7)),

mapstructure.go

@@ -756,10 +756,10 @@ func (d *Decoder) decodeString(name string, data any, val reflect.Value) error {
 			if dataKind == reflect.Array {
 				uints = make([]uint8, dataVal.Len())
 				for i := range uints {
-					uints[i] = dataVal.Index(i).Interface().(uint8)
+					uints[i] = uint8(dataVal.Index(i).Uint())
 				}
 			} else {
-				uints = dataVal.Interface().([]uint8)
+				uints = dataVal.Bytes()
 			}
 			val.SetString(string(uints))
 		default:

mapstructure_test.go

@@ -1524,6 +1524,38 @@ func TestDecode_StructMatch(t *testing.T) {
 	}
 }
 
+func TestWeakDecode_NamedBytesToString(t *testing.T) {
+	type octet uint8
+	type bytes []byte
+	type octets []octet
+
+	cases := []struct {
+		name  string
+		input any
+		want  string
+	}{
+		{"named slice", bytes{'f', 'o', 'o'}, "foo"},
+		{"named element slice", []octet{'f', 'o', 'o'}, "foo"},
+		{"named slice and elements", octets{'f', 'o', 'o'}, "foo"},
+		{"named element array", [3]octet{'f', 'o', 'o'}, "foo"},
+		{"nil slice", octets(nil), ""},
+		{"empty slice", octets{}, ""},
+		{"empty array", [0]octet{}, ""},
+		{"binary bytes", []octet{0, 128, 255}, "\x00\x80\xff"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			var got string
+			if err := WeakDecode(tc.input, &got); err != nil {
+				t.Fatal(err)
+			}
+			if got != tc.want {
+				t.Fatalf("expected %q, got %q", tc.want, got)
+			}
+		})
+	}
+}
+
 func TestDecode_TypeConversion(t *testing.T) {
 	input := map[string]any{
 		"IntToFloat":         42,