Resource export is unclear

Hi!
I'm in the middle of migrating from the old binding generator in wit-bindgen to the latest version of wit-bindgen-go and got confused by what exactly new way of exporting resources is.

Let's take an example where we define and export a counter resource:

package resource:example;

interface api {
  resource counter {
    constructor(name: string);
    add: func(value: u64);
    get: func() -> u64;
  }
}

world example {
  export api;
}

In the old binding generator to export this, it was possible to write a Go struct with methods on it and a constructor on the exported type:

// struct representing the component
type ResourceExampleImpl struct {
}

// struct representing an instance of the resource
type Counter struct {
	name    string
	current uint64
}

func (e *ResourceExampleImpl) ConstructorCounter(name string) resource_example.ExportsResourceExampleApiCounter {
	return &Counter{
		name:    name,
		current: 0,
	}
}

func (e *Counter) MethodCounterAdd(value uint64) {
	e.current += value
}

func (e *Counter) MethodCounterGet() uint64 {
	return e.current
}

func init() {
	resource_example.SetExportsResourceExampleApi(&ResourceExampleImpl{})
}

With the latest wit-bindgen-go the only way I found to do the same is to manually maintain a map of the generated resources indexed by cm.Rep:

type Counter struct {
	name    string
	current uint64
}

func NewCounter(name string) *Counter {
	return &Counter{
		name:    name,
		current: 0,
	}
}

func (e *Counter) Add(value uint64) {
	e.current += value
}

func (e *Counter) Get() uint64 {
	return e.current
}

var counters = make(map[cm.Rep]*Counter)
var lastId = cm.Rep(0)

func init() {
	resourceexampleapi.Exports.Counter.Constructor = func(name string) (result resourceexampleapi.Counter) {
		counter := NewCounter(name)
		id := lastId + 1
		lastId = id
		counters[id] = counter
		return resourceexampleapi.CounterResourceNew(id)
	}

	resourceexampleapi.Exports.Counter.Destructor = func(id cm.Rep) {
		delete(counters, id)
	}

	resourceexampleapi.Exports.Counter.Add = func(id cm.Rep, value uint64) {
		counters[id].Add(value)
	}

	resourceexampleapi.Exports.Counter.Get = func(id cm.Rep) uint64 {
		return counters[id].Get()
	}
}

Is this how it is supposed to work or am I missing something?
The new binding generator version is much nicer than the previous one in many ways, but having to manually keep track of resources seems weird to me.

Comienza comparando las API de exportación de recursos antiguas y más recientes de wit-bindgen-go usando el ejemplo de contador de WIT y los handlers resourceexampleapi.Exports.Counter generados. Determina si cm.Rep y el mapa manual counters son intencionados; después documenta o propone el comportamiento esperado del ciclo de vida del recurso y valídalo con una prueba aplicable de generación de bindings, si existe alguna.