Resource export is unclear

Start by comparing the old and latest wit-bindgen-go resource export APIs using the WIT counter example and the generated resourceexampleapi.Exports.Counter handlers. Determine whether cm.Rep and the manual counters map are intended, then document or propose the expected resource-lifecycle behavior and validate it with an applicable binding-generation test if one exists.

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.