pointer

func (*Registry) Register(v any)
{
	t := reflect.TypeOf(v)
	if t.Kind() == reflect.Ptr {
		t = t.Elem()
	}
	if t.Kind() != reflect.Struct {
		panic(fmt.Sprintf("pointer.Register: expected struct, got %s", t.Kind()))
	}

	r.mu.Lock()
	defer r.mu.Unlock()

	if _, ok := r.cache[t]; ok {
		return
	}

	tm := &typeMap{byOff: make(map[uintptr]*FieldInfo)}

	for i := 0; i < t.NumField(); i++ {
		sf := t.Field(i)
		if !sf.IsExported() {
			continue
		}

		fi := FieldInfo{
			Name:   sf.Name,
			Offset: sf.Offset,
			Type:   sf.Type,
		}

		if r.tagName != "" {
			tagStr := sf.Tag.Get(r.tagName)
			if tagStr != "" {
				fi.Tags = r.parser.Parse(tagStr)
			}
		}

		tm.fields = append(tm.fields, fi)
		tm.byOff[sf.Offset] = &tm.fields[len(tm.fields)-1]
	}

	r.cache[t] = tm
}

func (*Registry) Resolve(base any, fieldPtr any) (*FieldInfo, error)
{
	bv := reflect.ValueOf(base)
	if bv.Kind() != reflect.Ptr || bv.Elem().Kind() != reflect.Struct {
		return nil, fmt.Errorf("base must be a pointer to a struct")
	}

	fv := reflect.ValueOf(fieldPtr)
	if fv.Kind() != reflect.Ptr {
		return nil, fmt.Errorf("fieldPtr must be a pointer")
	}

	baseAddr := bv.Pointer()
	fieldAddr := fv.Pointer()
	offset := fieldAddr - baseAddr

	r.mu.RLock()
	tm, ok := r.cache[bv.Elem().Type()]
	r.mu.RUnlock()

	if !ok {
		return nil, fmt.Errorf("type %s not registered", bv.Elem().Type())
	}

	fi, ok := tm.byOff[offset]
	if !ok {
		return nil, fmt.Errorf("offset %d not found in type %s", offset, bv.Elem().Type())
	}

	return fi, nil
}