@keyhive/keyhive 0.0.0-alpha.4 → 0.0.0-alpha.41

package/pkg-slim/keyhive_wasm.js

@@ -30,24 +30,75 @@ function getStringFromWasm0(ptr, len) {
     return decodeText(ptr, len);
 }
 
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_export_2.set(idx, obj);
-    return idx;
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
     }
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
 }
 
 let WASM_VECTOR_LEN = 0;
@@ -113,82 +164,44 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches && builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
     }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
 }
 
 const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(
-state => {
-    wasm.__wbindgen_export_6.get(state.dtor)(state.a, state.b);
-}
-);
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
 
 function makeMutClosure(arg0, arg1, dtor, f) {
     const state = { a: arg0, b: arg1, cnt: 1, dtor };
@@ -203,30 +216,21 @@ function makeMutClosure(arg0, arg1, dtor, f) {
         try {
             return f(a, state.b, ...args);
         } finally {
-            if (--state.cnt === 0) {
-                wasm.__wbindgen_export_6.get(state.dtor)(a, state.b);
-                CLOSURE_DTORS.unregister(state);
-            } else {
-                state.a = a;
-            }
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
         }
     };
-    real.original = state;
     CLOSURE_DTORS.register(real, state, state);
     return real;
 }
 
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
-
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -235,17 +239,11 @@ function passArray8ToWasm0(arg, malloc) {
 }
 
 function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_2.get(idx);
+    const value = wasm.__wbindgen_externrefs.get(idx);
     wasm.__externref_table_dealloc(idx);
     return value;
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     for (let i = 0; i < array.length; i++) {
@@ -265,12 +263,12 @@ export function setPanicHook() {
     wasm.setPanicHook();
 }
 
-function __wbg_adapter_14(arg0, arg1, arg2) {
-    wasm.closure423_externref_shim(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h06e685b12973e965(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h06e685b12973e965(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_274(arg0, arg1, arg2, arg3) {
-    wasm.closure571_externref_shim(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h4666a87517ff844e(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h4666a87517ff844e(arg0, arg1, arg2, arg3);
 }
 
 const AccessFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -326,49 +324,6 @@ export class Access {
 }
 if (Symbol.dispose) Access.prototype[Symbol.dispose] = Access.prototype.free;
 
-const AddMemberErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_addmembererror_free(ptr >>> 0, 1));
-
-export class AddMemberError {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(AddMemberError.prototype);
-        obj.__wbg_ptr = ptr;
-        AddMemberErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        AddMemberErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_addmembererror_free(ptr, 0);
-    }
-    /**
-     * @returns {string}
-     */
-    message() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.addmembererror_message(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-}
-if (Symbol.dispose) AddMemberError.prototype[Symbol.dispose] = AddMemberError.prototype.free;
-
 const AgentFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_agent_free(ptr >>> 0, 1));
@@ -495,17 +450,14 @@ export class Archive {
      * @param {CiphertextStore} ciphertext_store
      * @param {Signer} signer
      * @param {Function} event_handler
-     * @returns {Keyhive}
+     * @returns {Promise<Keyhive>}
      */
     tryToKeyhive(ciphertext_store, signer, event_handler) {
         _assertClass(ciphertext_store, CiphertextStore);
         var ptr0 = ciphertext_store.__destroy_into_raw();
         _assertClass(signer, Signer);
         const ret = wasm.archive_tryToKeyhive(this.__wbg_ptr, ptr0, signer.__wbg_ptr, event_handler);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Keyhive.__wrap(ret[0]);
+        return ret;
     }
 }
 if (Symbol.dispose) Archive.prototype[Symbol.dispose] = Archive.prototype.free;
@@ -658,22 +610,22 @@ export class CgkaOperation {
 }
 if (Symbol.dispose) CgkaOperation.prototype[Symbol.dispose] = CgkaOperation.prototype.free;
 
-const ChangeRefFinalization = (typeof FinalizationRegistry === 'undefined')
+const ChangeIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_changeref_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_changeid_free(ptr >>> 0, 1));
 
-export class ChangeRef {
+export class ChangeId {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(ChangeRef.prototype);
+        const obj = Object.create(ChangeId.prototype);
         obj.__wbg_ptr = ptr;
-        ChangeRefFinalization.register(obj, obj.__wbg_ptr, obj);
+        ChangeIdFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     static __unwrap(jsValue) {
-        if (!(jsValue instanceof ChangeRef)) {
+        if (!(jsValue instanceof ChangeId)) {
             return 0;
         }
         return jsValue.__destroy_into_raw();
@@ -682,13 +634,13 @@ export class ChangeRef {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ChangeRefFinalization.unregister(this);
+        ChangeIdFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_changeref_free(ptr, 0);
+        wasm.__wbg_changeid_free(ptr, 0);
     }
     /**
      * @param {Uint8Array} bytes
@@ -696,22 +648,30 @@ export class ChangeRef {
     constructor(bytes) {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.changeref_new(ptr0, len0);
+        const ret = wasm.changeid_new(ptr0, len0);
         this.__wbg_ptr = ret >>> 0;
-        ChangeRefFinalization.register(this, this.__wbg_ptr, this);
+        ChangeIdFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
      * @returns {Uint8Array}
      */
     get bytes() {
-        const ret = wasm.changeref_bytes(this.__wbg_ptr);
+        const ret = wasm.changeid_bytes(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * r" Upcasts to the JS-import type for [`#ty_ident`].
+     * @returns {ChangeId}
+     */
+    __wasm_refgen_toChangeId() {
+        const ret = wasm.changeid___wasm_refgen_toChangeId(this.__wbg_ptr);
+        return ChangeId.__wrap(ret);
+    }
 }
-if (Symbol.dispose) ChangeRef.prototype[Symbol.dispose] = ChangeRef.prototype.free;
+if (Symbol.dispose) ChangeId.prototype[Symbol.dispose] = ChangeId.prototype.free;
 
 const CiphertextStoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -804,6 +764,13 @@ export class ContactCard {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @returns {Agent}
+     */
+    toAgent() {
+        const ret = wasm.contactcard_toAgent(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
     /**
      * @param {string} json
      * @returns {ContactCard}
@@ -897,26 +864,6 @@ export class Delegation {
 }
 if (Symbol.dispose) Delegation.prototype[Symbol.dispose] = Delegation.prototype.free;
 
-const DelegationErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_delegationerror_free(ptr >>> 0, 1));
-
-export class DelegationError {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        DelegationErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_delegationerror_free(ptr, 0);
-    }
-}
-if (Symbol.dispose) DelegationError.prototype[Symbol.dispose] = DelegationError.prototype.free;
-
 const DocContentRefsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_doccontentrefs_free(ptr >>> 0, 1));
@@ -944,7 +891,7 @@ export class DocContentRefs {
     }
     /**
      * @param {DocumentId} doc_id
-     * @param {ChangeRef[]} change_hashes
+     * @param {ChangeId[]} change_hashes
      */
     constructor(doc_id, change_hashes) {
         _assertClass(doc_id, DocumentId);
@@ -960,12 +907,14 @@ export class DocContentRefs {
         return this;
     }
     /**
-     * @param {ChangeRef} hash
+     * @param {ChangeId} hash
+     * @returns {Promise<void>}
      */
-    addChangeRef(hash) {
-        _assertClass(hash, ChangeRef);
+    addChangeId(hash) {
+        _assertClass(hash, ChangeId);
         var ptr0 = hash.__destroy_into_raw();
-        wasm.doccontentrefs_addChangeRef(this.__wbg_ptr, ptr0);
+        const ret = wasm.doccontentrefs_addChangeId(this.__wbg_ptr, ptr0);
+        return ret;
     }
     /**
      * @returns {DocumentId}
@@ -975,13 +924,11 @@ export class DocContentRefs {
         return DocumentId.__wrap(ret);
     }
     /**
-     * @returns {ChangeRef[]}
+     * @returns {Promise<ChangeId[]>}
      */
     get change_hashes() {
         const ret = wasm.doccontentrefs_change_hashes(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
 }
 if (Symbol.dispose) DocContentRefs.prototype[Symbol.dispose] = DocContentRefs.prototype.free;
@@ -1000,13 +947,6 @@ export class Document {
         return obj;
     }
 
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof Document)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -1022,7 +962,7 @@ export class Document {
      * @returns {Identifier}
      */
     get id() {
-        const ret = wasm.document_id(this.__wbg_ptr);
+        const ret = wasm.document_doc_id(this.__wbg_ptr);
         return Identifier.__wrap(ret);
     }
     /**
@@ -1046,6 +986,21 @@ export class Document {
         const ret = wasm.document_toAgent(this.__wbg_ptr);
         return Agent.__wrap(ret);
     }
+    /**
+     * @returns {Membered}
+     */
+    toMembered() {
+        const ret = wasm.document_toMembered(this.__wbg_ptr);
+        return Membered.__wrap(ret);
+    }
+    /**
+     * r" Upcasts to the JS-import type for [`#ty_ident`].
+     * @returns {Document}
+     */
+    __wasm_refgen_toDocument() {
+        const ret = wasm.document___wasm_refgen_toDocument(this.__wbg_ptr);
+        return Document.__wrap(ret);
+    }
 }
 if (Symbol.dispose) Document.prototype[Symbol.dispose] = Document.prototype.free;
 
@@ -1091,11 +1046,11 @@ export class DocumentId {
     /**
      * @returns {string}
      */
-    fromString() {
+    toString() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.documentid_fromString(this.__wbg_ptr);
+            const ret = wasm.documentid_toString(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -1314,51 +1269,22 @@ export class Event {
         const ret = wasm.event_tryIntoSignedRevocation(this.__wbg_ptr);
         return ret === 0 ? undefined : SignedRevocation.__wrap(ret);
     }
-}
-if (Symbol.dispose) Event.prototype[Symbol.dispose] = Event.prototype.free;
-
-const GenerateDocErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_generatedocerror_free(ptr >>> 0, 1));
-
-export class GenerateDocError {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(GenerateDocError.prototype);
-        obj.__wbg_ptr = ptr;
-        GenerateDocErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GenerateDocErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_generatedocerror_free(ptr, 0);
-    }
     /**
-     * @returns {string}
+     * Converts the underlying [`Event`] to a [`StaticEvent`] and then
+     * serializes it.
+     * @returns {Uint8Array}
      */
-    message() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.generatedocerror_message(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    toBytes() {
+        const ret = wasm.event_toBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
         }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
     }
 }
-if (Symbol.dispose) GenerateDocError.prototype[Symbol.dispose] = GenerateDocError.prototype.free;
+if (Symbol.dispose) Event.prototype[Symbol.dispose] = Event.prototype.free;
 
 const GenerateWebCryptoErrorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -1403,41 +1329,6 @@ export class GenerateWebCryptoError {
 }
 if (Symbol.dispose) GenerateWebCryptoError.prototype[Symbol.dispose] = GenerateWebCryptoError.prototype.free;
 
-const GetCiphertextErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_getciphertexterror_free(ptr >>> 0, 1));
-
-export class GetCiphertextError {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GetCiphertextErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_getciphertexterror_free(ptr, 0);
-    }
-    /**
-     * @returns {string}
-     */
-    get message() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.getciphertexterror_message(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-}
-if (Symbol.dispose) GetCiphertextError.prototype[Symbol.dispose] = GetCiphertextError.prototype.free;
-
 const GroupFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_group_free(ptr >>> 0, 1));
@@ -1467,24 +1358,22 @@ export class Group {
      * @returns {Identifier}
      */
     get id() {
-        const ret = wasm.group_id(this.__wbg_ptr);
+        const ret = wasm.document_doc_id(this.__wbg_ptr);
         return Identifier.__wrap(ret);
     }
     /**
      * @returns {GroupId}
      */
     get groupId() {
-        const ret = wasm.group_groupId(this.__wbg_ptr);
+        const ret = wasm.document_doc_id(this.__wbg_ptr);
         return GroupId.__wrap(ret);
     }
     /**
-     * @returns {Capability[]}
+     * @returns {Promise<Capability[]>}
      */
-    get members() {
+    members() {
         const ret = wasm.group_members(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
      * @returns {Peer}
@@ -1507,6 +1396,14 @@ export class Group {
         const ret = wasm.group_toMembered(this.__wbg_ptr);
         return Membered.__wrap(ret);
     }
+    /**
+     * r" Upcasts to the JS-import type for [`#ty_ident`].
+     * @returns {Group}
+     */
+    __wasm_refgen_toGroup() {
+        const ret = wasm.group___wasm_refgen_toGroup(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
 }
 if (Symbol.dispose) Group.prototype[Symbol.dispose] = Group.prototype.free;
 
@@ -1709,18 +1606,18 @@ export class Individual {
      * @returns {IndividualId}
      */
     get individualId() {
-        const ret = wasm.individual_individualId(this.__wbg_ptr);
+        const ret = wasm.individual_id(this.__wbg_ptr);
         return IndividualId.__wrap(ret);
     }
     /**
      * @param {DocumentId} doc_id
-     * @returns {ShareKey}
+     * @returns {Promise<ShareKey>}
      */
     pickPrekey(doc_id) {
         _assertClass(doc_id, DocumentId);
         var ptr0 = doc_id.__destroy_into_raw();
         const ret = wasm.individual_pickPrekey(this.__wbg_ptr, ptr0);
-        return ShareKey.__wrap(ret);
+        return ret;
     }
 }
 if (Symbol.dispose) Individual.prototype[Symbol.dispose] = Individual.prototype.free;
@@ -1782,118 +1679,6 @@ export class Invocation {
 }
 if (Symbol.dispose) Invocation.prototype[Symbol.dispose] = Invocation.prototype.free;
 
-const JsDecryptErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jsdecrypterror_free(ptr >>> 0, 1));
-
-export class JsDecryptError {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(JsDecryptError.prototype);
-        obj.__wbg_ptr = ptr;
-        JsDecryptErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsDecryptErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsdecrypterror_free(ptr, 0);
-    }
-}
-if (Symbol.dispose) JsDecryptError.prototype[Symbol.dispose] = JsDecryptError.prototype.free;
-
-const JsEncryptErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jsencrypterror_free(ptr >>> 0, 1));
-
-export class JsEncryptError {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(JsEncryptError.prototype);
-        obj.__wbg_ptr = ptr;
-        JsEncryptErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsEncryptErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsencrypterror_free(ptr, 0);
-    }
-}
-if (Symbol.dispose) JsEncryptError.prototype[Symbol.dispose] = JsEncryptError.prototype.free;
-
-const JsReceivePreKeyOpErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jsreceiveprekeyoperror_free(ptr >>> 0, 1));
-
-export class JsReceivePreKeyOpError {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(JsReceivePreKeyOpError.prototype);
-        obj.__wbg_ptr = ptr;
-        JsReceivePreKeyOpErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsReceivePreKeyOpErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsreceiveprekeyoperror_free(ptr, 0);
-    }
-}
-if (Symbol.dispose) JsReceivePreKeyOpError.prototype[Symbol.dispose] = JsReceivePreKeyOpError.prototype.free;
-
-const JsReceiveStaticEventErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_jsreceivestaticeventerror_free(ptr >>> 0, 1));
-
-export class JsReceiveStaticEventError {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(JsReceiveStaticEventError.prototype);
-        obj.__wbg_ptr = ptr;
-        JsReceiveStaticEventErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsReceiveStaticEventErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsreceivestaticeventerror_free(ptr, 0);
-    }
-}
-if (Symbol.dispose) JsReceiveStaticEventError.prototype[Symbol.dispose] = JsReceiveStaticEventError.prototype.free;
-
 const KeyhiveFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_keyhive_free(ptr >>> 0, 1));
@@ -1928,8 +1713,7 @@ export class Keyhive {
     static init(signer, ciphertext_store, event_handler) {
         _assertClass(signer, Signer);
         _assertClass(ciphertext_store, CiphertextStore);
-        var ptr0 = ciphertext_store.__destroy_into_raw();
-        const ret = wasm.keyhive_init(signer.__wbg_ptr, ptr0, event_handler);
+        const ret = wasm.keyhive_init(signer.__wbg_ptr, ciphertext_store.__wbg_ptr, event_handler);
         return ret;
     }
     /**
@@ -1946,6 +1730,13 @@ export class Keyhive {
         const ret = wasm.keyhive_id(this.__wbg_ptr);
         return IndividualId.__wrap(ret);
     }
+    /**
+     * @returns {Promise<Individual>}
+     */
+    get individual() {
+        const ret = wasm.keyhive_individual(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {string}
      */
@@ -1962,25 +1753,25 @@ export class Keyhive {
         }
     }
     /**
-     * @param {Peer[]} coparents
+     * @param {Peer[]} js_coparents
      * @returns {Promise<Group>}
      */
-    generateGroup(coparents) {
-        const ptr0 = passArrayJsValueToWasm0(coparents, wasm.__wbindgen_malloc);
+    generateGroup(js_coparents) {
+        const ptr0 = passArrayJsValueToWasm0(js_coparents, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.keyhive_generateGroup(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
      * @param {Peer[]} coparents
-     * @param {ChangeRef} initial_content_ref_head
-     * @param {ChangeRef[]} more_initial_content_refs
+     * @param {ChangeId} initial_content_ref_head
+     * @param {ChangeId[]} more_initial_content_refs
      * @returns {Promise<Document>}
      */
     generateDocument(coparents, initial_content_ref_head, more_initial_content_refs) {
         const ptr0 = passArrayJsValueToWasm0(coparents, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        _assertClass(initial_content_ref_head, ChangeRef);
+        _assertClass(initial_content_ref_head, ChangeId);
         var ptr1 = initial_content_ref_head.__destroy_into_raw();
         const ptr2 = passArrayJsValueToWasm0(more_initial_content_refs, wasm.__wbindgen_malloc);
         const len2 = WASM_VECTOR_LEN;
@@ -1999,17 +1790,17 @@ export class Keyhive {
     }
     /**
      * @param {Document} doc
-     * @param {ChangeRef} content_ref
-     * @param {ChangeRef[]} pred_refs
+     * @param {ChangeId} content_ref
+     * @param {ChangeId[]} js_pred_refs
      * @param {Uint8Array} content
      * @returns {Promise<EncryptedContentWithUpdate>}
      */
-    tryEncrypt(doc, content_ref, pred_refs, content) {
+    tryEncrypt(doc, content_ref, js_pred_refs, content) {
         _assertClass(doc, Document);
         var ptr0 = doc.__destroy_into_raw();
-        _assertClass(content_ref, ChangeRef);
+        _assertClass(content_ref, ChangeId);
         var ptr1 = content_ref.__destroy_into_raw();
-        const ptr2 = passArrayJsValueToWasm0(pred_refs, wasm.__wbindgen_malloc);
+        const ptr2 = passArrayJsValueToWasm0(js_pred_refs, wasm.__wbindgen_malloc);
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passArray8ToWasm0(content, wasm.__wbindgen_malloc);
         const len3 = WASM_VECTOR_LEN;
@@ -2018,40 +1809,31 @@ export class Keyhive {
     }
     /**
      * @param {Document} doc
-     * @param {ChangeRef} content_ref
-     * @param {ChangeRef[]} pred_refs
+     * @param {ChangeId} content_ref
+     * @param {ChangeId[]} pred_refs
      * @param {Uint8Array} content
      * @returns {Promise<EncryptedContentWithUpdate>}
      */
     tryEncryptArchive(doc, content_ref, pred_refs, content) {
         _assertClass(doc, Document);
-        var ptr0 = doc.__destroy_into_raw();
-        _assertClass(content_ref, ChangeRef);
-        var ptr1 = content_ref.__destroy_into_raw();
-        const ptr2 = passArrayJsValueToWasm0(pred_refs, wasm.__wbindgen_malloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passArray8ToWasm0(content, wasm.__wbindgen_malloc);
-        const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.keyhive_tryEncryptArchive(this.__wbg_ptr, ptr0, ptr1, ptr2, len2, ptr3, len3);
+        _assertClass(content_ref, ChangeId);
+        const ptr0 = passArrayJsValueToWasm0(pred_refs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(content, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_tryEncryptArchive(this.__wbg_ptr, doc.__wbg_ptr, content_ref.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
     /**
      * @param {Document} doc
      * @param {Encrypted} encrypted
-     * @returns {Uint8Array}
+     * @returns {Promise<Uint8Array>}
      */
     tryDecrypt(doc, encrypted) {
         _assertClass(doc, Document);
-        var ptr0 = doc.__destroy_into_raw();
         _assertClass(encrypted, Encrypted);
-        var ptr1 = encrypted.__destroy_into_raw();
-        const ret = wasm.keyhive_tryDecrypt(this.__wbg_ptr, ptr0, ptr1);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v3;
+        const ret = wasm.keyhive_tryDecrypt(this.__wbg_ptr, doc.__wbg_ptr, encrypted.__wbg_ptr);
+        return ret;
     }
     /**
      * @param {Agent} to_add
@@ -2083,13 +1865,11 @@ export class Keyhive {
         return ret;
     }
     /**
-     * @returns {Summary[]}
+     * @returns {Promise<Summary[]>}
      */
     reachableDocs() {
         const ret = wasm.keyhive_reachableDocs(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
      * @param {Document} doc
@@ -2126,71 +1906,74 @@ export class Keyhive {
     }
     /**
      * @param {ContactCard} contact_card
-     * @returns {Individual}
+     * @returns {Promise<Individual>}
      */
     receiveContactCard(contact_card) {
         _assertClass(contact_card, ContactCard);
-        var ptr0 = contact_card.__destroy_into_raw();
-        const ret = wasm.keyhive_receiveContactCard(this.__wbg_ptr, ptr0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Individual.__wrap(ret[0]);
+        const ret = wasm.keyhive_receiveContactCard(this.__wbg_ptr, contact_card.__wbg_ptr);
+        return ret;
     }
     /**
      * @param {Identifier} id
-     * @returns {Agent | undefined}
+     * @returns {Promise<Agent | undefined>}
      */
     getAgent(id) {
         _assertClass(id, Identifier);
         const ret = wasm.keyhive_getAgent(this.__wbg_ptr, id.__wbg_ptr);
-        return ret === 0 ? undefined : Agent.__wrap(ret);
+        return ret;
     }
     /**
-     * @param {Identifier} id
-     * @returns {Group | undefined}
+     * @param {GroupId} group_id
+     * @returns {Promise<Group | undefined>}
      */
-    getGroup(id) {
-        _assertClass(id, Identifier);
-        const ret = wasm.keyhive_getGroup(this.__wbg_ptr, id.__wbg_ptr);
-        return ret === 0 ? undefined : Group.__wrap(ret);
+    getGroup(group_id) {
+        _assertClass(group_id, GroupId);
+        const ret = wasm.keyhive_getGroup(this.__wbg_ptr, group_id.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {DocumentId} doc_id
+     * @returns {Promise<Document | undefined>}
+     */
+    getDocument(doc_id) {
+        _assertClass(doc_id, DocumentId);
+        const ret = wasm.keyhive_getDocument(this.__wbg_ptr, doc_id.__wbg_ptr);
+        return ret;
     }
     /**
      * @param {DocumentId} doc_id
-     * @returns {SimpleCapability[]}
+     * @returns {Promise<Membership[]>}
      */
     docMemberCapabilities(doc_id) {
         _assertClass(doc_id, DocumentId);
         const ret = wasm.keyhive_docMemberCapabilities(this.__wbg_ptr, doc_id.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+        return ret;
     }
     /**
      * @param {Identifier} id
      * @param {DocumentId} doc_id
-     * @returns {Access | undefined}
+     * @returns {Promise<Access | undefined>}
      */
     accessForDoc(id, doc_id) {
         _assertClass(id, Identifier);
         _assertClass(doc_id, DocumentId);
         const ret = wasm.keyhive_accessForDoc(this.__wbg_ptr, id.__wbg_ptr, doc_id.__wbg_ptr);
-        return ret === 0 ? undefined : Access.__wrap(ret);
+        return ret;
     }
     /**
-     * @returns {Archive}
+     * @returns {Promise<Archive>}
      */
     intoArchive() {
         const ptr = this.__destroy_into_raw();
         const ret = wasm.keyhive_intoArchive(ptr);
-        return Archive.__wrap(ret);
+        return ret;
     }
     /**
-     * @returns {Archive}
+     * @returns {Promise<Archive>}
      */
     toArchive() {
         const ret = wasm.keyhive_toArchive(this.__wbg_ptr);
-        return Archive.__wrap(ret);
+        return ret;
     }
     /**
      * @param {Archive} archive
@@ -2201,6 +1984,21 @@ export class Keyhive {
         const ret = wasm.keyhive_ingestArchive(this.__wbg_ptr, archive.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {Array<any>} events_bytes_array
+     * @returns {Promise<Array<any>>}
+     */
+    ingestEventsBytes(events_bytes_array) {
+        const ret = wasm.keyhive_ingestEventsBytes(this.__wbg_ptr, events_bytes_array);
+        return ret;
+    }
+    /**
+     * @returns {Promise<Stats>}
+     */
+    stats() {
+        const ret = wasm.keyhive_stats(this.__wbg_ptr);
+        return ret;
+    }
 }
 if (Symbol.dispose) Keyhive.prototype[Symbol.dispose] = Keyhive.prototype.free;
 
@@ -2232,47 +2030,89 @@ export class Membered {
 }
 if (Symbol.dispose) Membered.prototype[Symbol.dispose] = Membered.prototype.free;
 
-const PeerFinalization = (typeof FinalizationRegistry === 'undefined')
+const MembershipFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_peer_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_membership_free(ptr >>> 0, 1));
 
-export class Peer {
+export class Membership {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Peer.prototype);
+        const obj = Object.create(Membership.prototype);
         obj.__wbg_ptr = ptr;
-        PeerFinalization.register(obj, obj.__wbg_ptr, obj);
+        MembershipFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof Peer)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PeerFinalization.unregister(this);
+        MembershipFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_peer_free(ptr, 0);
+        wasm.__wbg_membership_free(ptr, 0);
     }
     /**
-     * @returns {string}
+     * @returns {Agent}
      */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.peer_toString(this.__wbg_ptr);
-            deferred1_0 = ret[0];
+    get who() {
+        const ret = wasm.membership_who(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
+    /**
+     * @returns {Access}
+     */
+    get can() {
+        const ret = wasm.membership_can(this.__wbg_ptr);
+        return Access.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Membership.prototype[Symbol.dispose] = Membership.prototype.free;
+
+const PeerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_peer_free(ptr >>> 0, 1));
+
+export class Peer {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Peer.prototype);
+        obj.__wbg_ptr = ptr;
+        PeerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PeerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_peer_free(ptr, 0);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get id() {
+        const ret = wasm.doccontentrefs_docId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.peer_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
         } finally {
@@ -2300,28 +2140,16 @@ export class Peer {
         const ret = wasm.peer_isDocument(this.__wbg_ptr);
         return ret !== 0;
     }
-}
-if (Symbol.dispose) Peer.prototype[Symbol.dispose] = Peer.prototype.free;
-
-const RemoveCiphertextErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_removeciphertexterror_free(ptr >>> 0, 1));
-
-export class RemoveCiphertextError {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        RemoveCiphertextErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_removeciphertexterror_free(ptr, 0);
+    /**
+     * r" Upcasts to the JS-import type for [`#ty_ident`].
+     * @returns {Peer}
+     */
+    __wasm_refgen_toPeer() {
+        const ret = wasm.peer___wasm_refgen_toPeer(this.__wbg_ptr);
+        return Peer.__wrap(ret);
     }
 }
-if (Symbol.dispose) RemoveCiphertextError.prototype[Symbol.dispose] = RemoveCiphertextError.prototype.free;
+if (Symbol.dispose) Peer.prototype[Symbol.dispose] = Peer.prototype.free;
 
 const RevocationFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2379,85 +2207,6 @@ export class Revocation {
 }
 if (Symbol.dispose) Revocation.prototype[Symbol.dispose] = Revocation.prototype.free;
 
-const RevokeMemberErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_revokemembererror_free(ptr >>> 0, 1));
-
-export class RevokeMemberError {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(RevokeMemberError.prototype);
-        obj.__wbg_ptr = ptr;
-        RevokeMemberErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        RevokeMemberErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_revokemembererror_free(ptr, 0);
-    }
-    /**
-     * @returns {string}
-     */
-    get message() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.revokemembererror_message(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-}
-if (Symbol.dispose) RevokeMemberError.prototype[Symbol.dispose] = RevokeMemberError.prototype.free;
-
-const SerializationErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_serializationerror_free(ptr >>> 0, 1));
-
-export class SerializationError {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(SerializationError.prototype);
-        obj.__wbg_ptr = ptr;
-        SerializationErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SerializationErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_serializationerror_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toError() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.serializationerror_toError(ptr);
-        return ret;
-    }
-}
-if (Symbol.dispose) SerializationError.prototype[Symbol.dispose] = SerializationError.prototype.free;
-
 const ShareKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_sharekey_free(ptr >>> 0, 1));
@@ -2519,13 +2268,19 @@ export class Signed {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.signed_fromBytes(ptr0, len0);
-        return Signed.__wrap(ret);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Signed.__wrap(ret[0]);
     }
     /**
      * @returns {Uint8Array}
      */
     toBytes() {
         const ret = wasm.signed_toBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -2878,90 +2633,68 @@ export class Signer {
 }
 if (Symbol.dispose) Signer.prototype[Symbol.dispose] = Signer.prototype.free;
 
-const SigningErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+const StatsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signingerror_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_stats_free(ptr >>> 0, 1));
 
-export class SigningError {
+export class Stats {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(SigningError.prototype);
+        const obj = Object.create(Stats.prototype);
         obj.__wbg_ptr = ptr;
-        SigningErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        StatsFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SigningErrorFinalization.unregister(this);
+        StatsFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_signingerror_free(ptr, 0);
+        wasm.__wbg_stats_free(ptr, 0);
     }
     /**
-     * @returns {string}
+     * @returns {bigint}
      */
-    message() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.signingerror_message(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-}
-if (Symbol.dispose) SigningError.prototype[Symbol.dispose] = SigningError.prototype.free;
-
-const SimpleCapabilityFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_simplecapability_free(ptr >>> 0, 1));
-
-export class SimpleCapability {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(SimpleCapability.prototype);
-        obj.__wbg_ptr = ptr;
-        SimpleCapabilityFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+    get individuals() {
+        const ret = wasm.stats_individuals(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SimpleCapabilityFinalization.unregister(this);
-        return ptr;
+    /**
+     * @returns {bigint}
+     */
+    get groups() {
+        const ret = wasm.stats_groups(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_simplecapability_free(ptr, 0);
+    /**
+     * @returns {bigint}
+     */
+    get docs() {
+        const ret = wasm.stats_docs(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-     * @returns {Agent}
+     * @returns {bigint}
      */
-    get who() {
-        const ret = wasm.simplecapability_who(this.__wbg_ptr);
-        return Agent.__wrap(ret);
+    get delegations() {
+        const ret = wasm.stats_delegations(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
     /**
-     * @returns {Access}
+     * @returns {bigint}
      */
-    get can() {
-        const ret = wasm.simplecapability_can(this.__wbg_ptr);
-        return Access.__wrap(ret);
+    get revocations() {
+        const ret = wasm.stats_revocations(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
 }
-if (Symbol.dispose) SimpleCapability.prototype[Symbol.dispose] = SimpleCapability.prototype.free;
+if (Symbol.dispose) Stats.prototype[Symbol.dispose] = Stats.prototype.free;
 
 const SummaryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -3005,42 +2738,6 @@ export class Summary {
 }
 if (Symbol.dispose) Summary.prototype[Symbol.dispose] = Summary.prototype.free;
 
-const TryFromArchiveErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_tryfromarchiveerror_free(ptr >>> 0, 1));
-
-export class TryFromArchiveError {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(TryFromArchiveError.prototype);
-        obj.__wbg_ptr = ptr;
-        TryFromArchiveErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        TryFromArchiveErrorFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_tryfromarchiveerror_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toError() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.tryfromarchiveerror_toError(ptr);
-        return ret;
-    }
-}
-if (Symbol.dispose) TryFromArchiveError.prototype[Symbol.dispose] = TryFromArchiveError.prototype.free;
-
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
@@ -3079,22 +2776,78 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_Error_e17e777aac105295 = function(arg0, arg1) {
+    imports.wbg.__wbg_Error_e83987f665cf5504 = function(arg0, arg1) {
         const ret = Error(getStringFromWasm0(arg0, arg1));
         return ret;
     };
-    imports.wbg.__wbg_addmembererror_new = function(arg0) {
-        const ret = AddMemberError.__wrap(arg0);
+    imports.wbg.__wbg___wasm_refgen_toChangeId_bdad356172ca9cbc = function(arg0) {
+        const ret = arg0.__wasm_refgen_toChangeId();
+        _assertClass(ret, ChangeId);
+        var ptr1 = ret.__destroy_into_raw();
+        return ptr1;
+    };
+    imports.wbg.__wbg___wasm_refgen_toDocument_970367efee8cb1d0 = function(arg0) {
+        const ret = arg0.__wasm_refgen_toDocument();
+        _assertClass(ret, Document);
+        var ptr1 = ret.__destroy_into_raw();
+        return ptr1;
+    };
+    imports.wbg.__wbg___wasm_refgen_toPeer_f5e24110e2d41e74 = function(arg0) {
+        const ret = arg0.__wasm_refgen_toPeer();
+        _assertClass(ret, Peer);
+        var ptr1 = ret.__destroy_into_raw();
+        return ptr1;
+    };
+    imports.wbg.__wbg___wbindgen_debug_string_df47ffb5e35e6763 = function(arg0, arg1) {
+        const ret = debugString(arg1);
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg___wbindgen_is_function_ee8a6c5833c90377 = function(arg0) {
+        const ret = typeof(arg0) === 'function';
         return ret;
     };
-    imports.wbg.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
-        const ret = arg0.call(arg1);
+    imports.wbg.__wbg___wbindgen_is_object_c818261d21f283a4 = function(arg0) {
+        const val = arg0;
+        const ret = typeof(val) === 'object' && val !== null;
         return ret;
-    }, arguments) };
-    imports.wbg.__wbg_call_a5400b25a865cfd8 = function() { return handleError(function (arg0, arg1, arg2) {
+    };
+    imports.wbg.__wbg___wbindgen_is_string_fbb76cb2940daafd = function(arg0) {
+        const ret = typeof(arg0) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_undefined_2d472862bd29a478 = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg__wbg_cb_unref_2454a539ea5790d9 = function(arg0) {
+        arg0._wbg_cb_unref();
+    };
+    imports.wbg.__wbg_access_new = function(arg0) {
+        const ret = Access.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_agent_new = function(arg0) {
+        const ret = Agent.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_archive_new = function(arg0) {
+        const ret = Archive.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_call_525440f72fbfc0ea = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = arg0.call(arg1, arg2);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_cannotparseed25519signingkey_new = function(arg0) {
         const ret = CannotParseEd25519SigningKey.__wrap(arg0);
         return ret;
@@ -3107,12 +2860,12 @@ function __wbg_get_imports() {
         const ret = Capability.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_changeref_new = function(arg0) {
-        const ret = ChangeRef.__wrap(arg0);
+    imports.wbg.__wbg_changeid_new = function(arg0) {
+        const ret = ChangeId.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_changeref_unwrap = function(arg0) {
-        const ret = ChangeRef.__unwrap(arg0);
+    imports.wbg.__wbg_changeid_unwrap = function(arg0) {
+        const ret = ChangeId.__unwrap(arg0);
         return ret;
     };
     imports.wbg.__wbg_contactcard_new = function(arg0) {
@@ -3123,10 +2876,28 @@ function __wbg_get_imports() {
         const ret = arg0.crypto;
         return ret;
     };
-    imports.wbg.__wbg_crypto_92ce5ebc02988b17 = function() { return handleError(function (arg0) {
-        const ret = arg0.crypto;
-        return ret;
-    }, arguments) };
+    imports.wbg.__wbg_debug_68afdd09483bcd1b = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.debug(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_debug_a4fe41d1a79aaba9 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.debug(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
     imports.wbg.__wbg_doccontentrefs_new = function(arg0) {
         const ret = DocContentRefs.__wrap(arg0);
         return ret;
@@ -3135,10 +2906,6 @@ function __wbg_get_imports() {
         const ret = Document.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_document_unwrap = function(arg0) {
-        const ret = Document.__unwrap(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_encryptedcontentwithupdate_new = function(arg0) {
         const ret = EncryptedContentWithUpdate.__wrap(arg0);
         return ret;
@@ -3154,22 +2921,40 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
+    imports.wbg.__wbg_error_be2b0d69ec6dd379 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
+    imports.wbg.__wbg_error_fa36d085107c9dd5 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
+    };
     imports.wbg.__wbg_event_new = function(arg0) {
         const ret = Event.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_exportKey_4a1163511775473d = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_exportKey_14f4c9c1691e79dc = function() { return handleError(function (arg0, arg1, arg2, arg3) {
         const ret = arg0.exportKey(getStringFromWasm0(arg1, arg2), arg3);
         return ret;
     }, arguments) };
-    imports.wbg.__wbg_generateKey_b8902ccb0e50ff4e = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    imports.wbg.__wbg_generateKey_3530d4e1a89ee5b4 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
         const ret = arg0.generateKey(getStringFromWasm0(arg1, arg2), arg3 !== 0, arg4);
         return ret;
     }, arguments) };
-    imports.wbg.__wbg_generatedocerror_new = function(arg0) {
-        const ret = GenerateDocError.__wrap(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_generatewebcryptoerror_new = function(arg0) {
         const ret = GenerateWebCryptoError.__wrap(arg0);
         return ret;
@@ -3177,15 +2962,19 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
         arg0.getRandomValues(arg1);
     }, arguments) };
-    imports.wbg.__wbg_get_458e874b43b18b25 = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_get_7bed016f185add81 = function(arg0, arg1) {
+        const ret = arg0[arg1 >>> 0];
+        return ret;
+    };
+    imports.wbg.__wbg_get_efcb449f58ec27c2 = function() { return handleError(function (arg0, arg1) {
         const ret = Reflect.get(arg0, arg1);
         return ret;
     }, arguments) };
-    imports.wbg.__wbg_getprivatekey_2b060a8a8c19d828 = function(arg0) {
+    imports.wbg.__wbg_get_private_key_0a3a263ca613b0c0 = function(arg0) {
         const ret = arg0.privateKey;
         return ret;
     };
-    imports.wbg.__wbg_getpublickey_ad4c2474164b2d9a = function(arg0) {
+    imports.wbg.__wbg_get_public_key_1e2c11d159e34827 = function(arg0) {
         const ret = arg0.publicKey;
         return ret;
     };
@@ -3193,62 +2982,89 @@ function __wbg_get_imports() {
         const ret = Group.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_instanceof_Crypto_33ac2d91cca59233 = function(arg0) {
-        let result;
-        try {
-            result = arg0 instanceof Crypto;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
+    imports.wbg.__wbg_individual_new = function(arg0) {
+        const ret = Individual.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_instanceof_Window_12d20d558ef92592 = function(arg0) {
+    imports.wbg.__wbg_instanceof_Crypto_2574e69763b89701 = function(arg0) {
         let result;
         try {
-            result = arg0 instanceof Window;
+            result = arg0 instanceof Crypto;
         } catch (_) {
             result = false;
         }
         const ret = result;
         return ret;
     };
-    imports.wbg.__wbg_jsdecrypterror_new = function(arg0) {
-        const ret = JsDecryptError.__wrap(arg0);
+    imports.wbg.__wbg_keyhive_new = function(arg0) {
+        const ret = Keyhive.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_jsencrypterror_new = function(arg0) {
-        const ret = JsEncryptError.__wrap(arg0);
+    imports.wbg.__wbg_length_69bca3cb64fc8748 = function(arg0) {
+        const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_jsreceiveprekeyoperror_new = function(arg0) {
-        const ret = JsReceivePreKeyOpError.__wrap(arg0);
+    imports.wbg.__wbg_length_cdd215e10d9dd507 = function(arg0) {
+        const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_jsreceivestaticeventerror_new = function(arg0) {
-        const ret = JsReceiveStaticEventError.__wrap(arg0);
-        return ret;
+    imports.wbg.__wbg_log_98ea330cbdc64a56 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.log(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
     };
-    imports.wbg.__wbg_keyhive_new = function(arg0) {
-        const ret = Keyhive.__wrap(arg0);
-        return ret;
+    imports.wbg.__wbg_log_f996de40931ab7d1 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.log(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
     };
-    imports.wbg.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
-        const ret = arg0.length;
+    imports.wbg.__wbg_mark_49688daf5a319979 = function(arg0, arg1) {
+        performance.mark(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_measure_52555d98d3c0f41a = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        let deferred0_0;
+        let deferred0_1;
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            deferred1_0 = arg2;
+            deferred1_1 = arg3;
+            performance.measure(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }, arguments) };
+    imports.wbg.__wbg_membership_new = function(arg0) {
+        const ret = Membership.__wrap(arg0);
         return ret;
     };
     imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
         const ret = arg0.msCrypto;
         return ret;
     };
-    imports.wbg.__wbg_new_2e3c58a15f39f5f9 = function(arg0, arg1) {
+    imports.wbg.__wbg_new_3c3d849046688a66 = function(arg0, arg1) {
         try {
             var state0 = {a: arg0, b: arg1};
             var cb0 = (arg0, arg1) => {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_274(a, state0.b, arg0, arg1);
+                    return wasm_bindgen__convert__closures_____invoke__h4666a87517ff844e(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -3259,7 +3075,7 @@ function __wbg_get_imports() {
             state0.a = state0.b = 0;
         }
     };
-    imports.wbg.__wbg_new_638ebfaedbf32a5e = function(arg0) {
+    imports.wbg.__wbg_new_5a79be3ab53b8aa5 = function(arg0) {
         const ret = new Uint8Array(arg0);
         return ret;
     };
@@ -3267,11 +3083,23 @@ function __wbg_get_imports() {
         const ret = new Error();
         return ret;
     };
-    imports.wbg.__wbg_newnoargs_254190557c45b4ec = function(arg0, arg1) {
+    imports.wbg.__wbg_new_a7442b4b19c1a356 = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_new_e17d9f43105b08be = function() {
+        const ret = new Array();
+        return ret;
+    };
+    imports.wbg.__wbg_new_from_slice_92f4d78ca282a2d2 = function(arg0, arg1) {
+        const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_new_no_args_ee98eee5275000a4 = function(arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return ret;
     };
-    imports.wbg.__wbg_newwithlength_a167dcc7aaa3ba77 = function(arg0) {
+    imports.wbg.__wbg_new_with_length_01aa0dc35aa13543 = function(arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return ret;
     };
@@ -3279,24 +3107,24 @@ function __wbg_get_imports() {
         const ret = arg0.node;
         return ret;
     };
-    imports.wbg.__wbg_peer_unwrap = function(arg0) {
-        const ret = Peer.__unwrap(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
         const ret = arg0.process;
         return ret;
     };
-    imports.wbg.__wbg_prototypesetcall_3d4a26c1ed734349 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {
         Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
     };
-    imports.wbg.__wbg_queueMicrotask_25d0739ac89e8c88 = function(arg0) {
-        queueMicrotask(arg0);
+    imports.wbg.__wbg_push_df81a39d04db858c = function(arg0, arg1) {
+        const ret = arg0.push(arg1);
+        return ret;
     };
-    imports.wbg.__wbg_queueMicrotask_4488407636f5bf24 = function(arg0) {
+    imports.wbg.__wbg_queueMicrotask_34d692c25c47d05b = function(arg0) {
         const ret = arg0.queueMicrotask;
         return ret;
     };
+    imports.wbg.__wbg_queueMicrotask_9d76cacb20c84d58 = function(arg0) {
+        queueMicrotask(arg0);
+    };
     imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
         arg0.randomFillSync(arg1);
     }, arguments) };
@@ -3304,23 +3132,18 @@ function __wbg_get_imports() {
         const ret = module.require;
         return ret;
     }, arguments) };
-    imports.wbg.__wbg_resolve_4055c623acdd6a1b = function(arg0) {
+    imports.wbg.__wbg_resolve_caf97c30b83f7053 = function(arg0) {
         const ret = Promise.resolve(arg0);
         return ret;
     };
-    imports.wbg.__wbg_revokemembererror_new = function(arg0) {
-        const ret = RevokeMemberError.__wrap(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_serializationerror_new = function(arg0) {
-        const ret = SerializationError.__wrap(arg0);
-        return ret;
+    imports.wbg.__wbg_set_name_d94846a29e626702 = function(arg0, arg1, arg2) {
+        arg0.name = getStringFromWasm0(arg1, arg2);
     };
     imports.wbg.__wbg_sharekey_new = function(arg0) {
         const ret = ShareKey.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_sign_8891059f121b31b5 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    imports.wbg.__wbg_sign_0077f2aabd37825a = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
         const ret = arg0.sign(arg1, arg2, getArrayU8FromWasm0(arg3, arg4));
         return ret;
     }, arguments) };
@@ -3340,14 +3163,6 @@ function __wbg_get_imports() {
         const ret = Signer.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_signingerror_new = function(arg0) {
-        const ret = SigningError.__wrap(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_simplecapability_new = function(arg0) {
-        const ret = SimpleCapability.__wrap(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = arg1.stack;
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -3355,27 +3170,31 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
-    imports.wbg.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12 = function() {
+    imports.wbg.__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e = function() {
         const ret = typeof global === 'undefined' ? null : global;
         return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     };
-    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184 = function() {
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac = function() {
         const ret = typeof globalThis === 'undefined' ? null : globalThis;
         return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     };
-    imports.wbg.__wbg_static_accessor_SELF_995b214ae681ff99 = function() {
+    imports.wbg.__wbg_static_accessor_SELF_6fdf4b64710cc91b = function() {
         const ret = typeof self === 'undefined' ? null : self;
         return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     };
-    imports.wbg.__wbg_static_accessor_WINDOW_cde3890479c675ea = function() {
+    imports.wbg.__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2 = function() {
         const ret = typeof window === 'undefined' ? null : window;
         return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     };
-    imports.wbg.__wbg_subarray_70fd07feefe14294 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_stats_new = function(arg0) {
+        const ret = Stats.__wrap(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_subarray_480600f3d6a9f26c = function(arg0, arg1, arg2) {
         const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
         return ret;
     };
-    imports.wbg.__wbg_subtle_dd66747d3e9a93d4 = function(arg0) {
+    imports.wbg.__wbg_subtle_a158c8cba320b8ed = function(arg0) {
         const ret = arg0.subtle;
         return ret;
     };
@@ -3383,72 +3202,84 @@ function __wbg_get_imports() {
         const ret = Summary.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_then_b33a773d723afa3e = function(arg0, arg1, arg2) {
-        const ret = arg0.then(arg1, arg2);
-        return ret;
-    };
-    imports.wbg.__wbg_then_e22500defe16819f = function(arg0, arg1) {
+    imports.wbg.__wbg_then_4f46f6544e6b4a28 = function(arg0, arg1) {
         const ret = arg0.then(arg1);
         return ret;
     };
-    imports.wbg.__wbg_tryfromarchiveerror_new = function(arg0) {
-        const ret = TryFromArchiveError.__wrap(arg0);
+    imports.wbg.__wbg_then_70d05cf780a18d77 = function(arg0, arg1, arg2) {
+        const ret = arg0.then(arg1, arg2);
         return ret;
     };
     imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
         const ret = arg0.versions;
         return ret;
     };
-    imports.wbg.__wbg_wbindgencbdrop_eb10308566512b88 = function(arg0) {
-        const obj = arg0.original;
-        if (obj.cnt-- == 1) {
-            obj.a = 0;
-            return true;
+    imports.wbg.__wbg_warn_c6311e9cb983aa2a = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.warn(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
-        const ret = false;
-        return ret;
     };
-    imports.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d = function(arg0, arg1) {
-        const ret = debugString(arg1);
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    imports.wbg.__wbg_warn_de3a09d072c895e6 = function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.warn(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
     };
-    imports.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
-        const ret = typeof(arg0) === 'function';
+    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        const ret = getStringFromWasm0(arg0, arg1);
         return ret;
     };
-    imports.wbg.__wbg_wbindgenisobject_307a53c6bd97fbf8 = function(arg0) {
-        const val = arg0;
-        const ret = typeof(val) === 'object' && val !== null;
+    imports.wbg.__wbindgen_cast_25a0a844437d0e92 = function(arg0, arg1) {
+        var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+        // Cast intrinsic for `Vector(NamedExternref("string")) -> Externref`.
+        const ret = v0;
         return ret;
     };
-    imports.wbg.__wbg_wbindgenisstring_d4fa939789f003b0 = function(arg0) {
-        const ret = typeof(arg0) === 'string';
+    imports.wbg.__wbindgen_cast_6300122139088863 = function(arg0, arg1) {
+        var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+        // Cast intrinsic for `Vector(NamedExternref("ChangeId")) -> Externref`.
+        const ret = v0;
         return ret;
     };
-    imports.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
-        const ret = arg0 === undefined;
+    imports.wbg.__wbindgen_cast_6d311b4990fb968e = function(arg0, arg1) {
+        var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+        // Cast intrinsic for `Vector(NamedExternref("Summary")) -> Externref`.
+        const ret = v0;
         return ret;
     };
-    imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
-        throw new Error(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbindgen_cast_133053e9d0cd85aa = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 422, function: Function { arguments: [Externref], shim_idx: 423, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, 422, __wbg_adapter_14);
+    imports.wbg.__wbindgen_cast_6e33e4871eebdb43 = function(arg0, arg1) {
+        var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+        // Cast intrinsic for `Vector(NamedExternref("Membership")) -> Externref`.
+        const ret = v0;
         return ret;
     };
-    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
-        // Cast intrinsic for `Ref(String) -> Externref`.
-        const ret = getStringFromWasm0(arg0, arg1);
+    imports.wbg.__wbindgen_cast_77bc3e92745e9a35 = function(arg0, arg1) {
+        var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 1, 1);
+        // Cast intrinsic for `Vector(U8) -> Externref`.
+        const ret = v0;
         return ret;
     };
-    imports.wbg.__wbindgen_cast_25a0a844437d0e92 = function(arg0, arg1) {
+    imports.wbg.__wbindgen_cast_a81e76255c07f2e8 = function(arg0, arg1) {
         var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
         wasm.__wbindgen_free(arg0, arg1 * 4, 4);
-        // Cast intrinsic for `Vector(NamedExternref("string")) -> Externref`.
+        // Cast intrinsic for `Vector(NamedExternref("Capability")) -> Externref`.
         const ret = v0;
         return ret;
     };
@@ -3459,13 +3290,18 @@ function __wbg_get_imports() {
         const ret = v0;
         return ret;
     };
+    imports.wbg.__wbindgen_cast_bef74971622929eb = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 462, function: Function { arguments: [Externref], shim_idx: 463, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__heb938d8490fb5a71, wasm_bindgen__convert__closures_____invoke__h06e685b12973e965);
+        return ret;
+    };
     imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
         const ret = getArrayU8FromWasm0(arg0, arg1);
         return ret;
     };
     imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_export_2;
+        const table = wasm.__wbindgen_externrefs;
         const offset = table.grow(4);
         table.set(0, undefined);
         table.set(offset + 0, undefined);
@@ -3478,10 +3314,6 @@ function __wbg_get_imports() {
     return imports;
 }
 
-function __wbg_init_memory(imports, memory) {
-
-}
-
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
@@ -3507,8 +3339,6 @@ function initSync(module) {
 
     const imports = __wbg_get_imports();
 
-    __wbg_init_memory(imports);
-
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
     }
@@ -3539,8 +3369,6 @@ async function __wbg_init(module_or_path) {
         module_or_path = fetch(module_or_path);
     }
 
-    __wbg_init_memory(imports);
-
     const { instance, module } = await __wbg_load(await module_or_path, imports);
 
     return __wbg_finalize_init(instance, module);