Understanding wasm-bindgen returned objects memory management

Question

I'm trying to return a typed object from Rust to Typescript, and I ideally don't want to have to manually manage memory (performance is not the highest priority). While doing this, I'm trying to understand the generated JS.

Rust:

#[wasm_bindgen]
pub fn retjs() -> JsValue {
    // in my actual project I serialize a struct with `JsValue::from_serde`
    JsValue::from_str("")
}

#[wasm_bindgen]
pub fn retstruct() -> A {
    A {
        a: "".to_owned(),
    };
}

#[wasm_bindgen]
pub struct A {
    a: String,
}

#[wasm_bindgen]
impl A {
    #[wasm_bindgen]
    pub fn foo(&self) -> String {
        return self.a.clone();
    }
}

Generated JS:

export function retjs() {
    const ret = wasm.retjs();
    return takeObject(ret);
}

function takeObject(idx) {
    const ret = getObject(idx);
    dropObject(idx);
    return ret;
}

function dropObject(idx) {
    if (idx < 36) return;
    heap[idx] = heap_next;
    heap_next = idx;
}

export function retstruct() {
    const ret = wasm.retstruct();
    return A.__wrap(ret);
}


// generated class A omitted for brevity. Here relevant that it has a `free()` method.

Is my understanding correct that with the JsValue the memory is completely freed automatically? And that I've to do this manually with the struct? Is there a way to get around that?

I basically just want type safety in Typescript, so when I update the struct in Rust the Typescript code is automatically updated.