@keyhive/keyhive 0.0.0-alpha.9 → 0.1.0-alpha.2

package/pkg/keyhive_wasm_bg.js

@@ -1,316 +1,19 @@
-let wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}
-
-
-let cachedUint8ArrayMemory0 = null;
-
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    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 getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-let WASM_VECTOR_LEN = 0;
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    }
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-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}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
-}
-
-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;
-}
-
-const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(
-state => {
-    wasm.__wbindgen_export_7.get(state.dtor)(state.a, state.b);
-}
-);
-
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
-        try {
-            return f(a, state.b, ...args);
-        } finally {
-            if (--state.cnt === 0) {
-                wasm.__wbindgen_export_7.get(state.dtor)(a, state.b);
-                CLOSURE_DTORS.unregister(state);
-            } else {
-                state.a = a;
-            }
-        }
-    };
-    real.original = state;
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_2.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++) {
-        const add = addToExternrefTable0(array[i]);
-        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
-    }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
-}
-/**
- * Panic hook lets us get better error messages if our Rust code ever panics.
- *
- * This function needs to be called at least once during initialisation.
- * https://rustwasm.github.io/docs/wasm-pack/tutorials/npm-browser-packages/template-deep-dive/src-utils-rs.html#2-what-is-console_error_panic_hook
- */
-export function setPanicHook() {
-    wasm.setPanicHook();
-}
-
-function __wbg_adapter_12(arg0, arg1, arg2) {
-    wasm.closure433_externref_shim(arg0, arg1, arg2);
-}
-
-function __wbg_adapter_273(arg0, arg1, arg2, arg3) {
-    wasm.closure574_externref_shim(arg0, arg1, arg2, arg3);
-}
-
-const AccessFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_access_free(ptr >>> 0, 1));
-
 export class Access {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Access.prototype);
         obj.__wbg_ptr = ptr;
         AccessFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        AccessFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_access_free(ptr, 0);
-    }
-    /**
-     * @param {string} s
-     * @returns {Access | undefined}
-     */
-    static tryFromString(s) {
-        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.access_tryFromString(ptr0, len0);
-        return ret === 0 ? undefined : Access.__wrap(ret);
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AccessFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_access_free(ptr, 0);
     }
     /**
      * @returns {string}
@@ -327,77 +30,129 @@ export class Access {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @param {string} s
+     * @returns {Access | undefined}
+     */
+    static tryFromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.access_tryFromString(ptr0, len0);
+        return ret === 0 ? undefined : Access.__wrap(ret);
+    }
 }
 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 {
-
+/**
+ * The result of adding a member: the membership delegation, plus any new leaf
+ * secrets produced by auto-rekeying a non-forward-secret document on add.
+ */
+export class AddMemberUpdate {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(AddMemberError.prototype);
+        const obj = Object.create(AddMemberUpdate.prototype);
         obj.__wbg_ptr = ptr;
-        AddMemberErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        AddMemberUpdateFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        AddMemberErrorFinalization.unregister(this);
+        AddMemberUpdateFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_addmembererror_free(ptr, 0);
+        wasm.__wbg_addmemberupdate_free(ptr, 0);
     }
     /**
-     * @returns {string}
+     * @returns {SignedDelegation}
      */
-    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);
+    get delegation() {
+        const ret = wasm.addmemberupdate_delegation(this.__wbg_ptr);
+        return SignedDelegation.__wrap(ret);
+    }
+    /**
+     * New leaf secret keypairs from auto-rekeying a non-forward-secret document
+     * when this reader was added, serialized as a
+     * `BTreeMap<ShareKey, ShareSecretKey>` (the format `importPrekeySecrets`
+     * accepts). A sibling instance of this identity (e.g. a tab and its
+     * SharedWorker) installs them to derive the rotated key. `undefined` when
+     * no rotation occurred (a forward-secret document).
+     * @returns {Uint8Array | undefined}
+     */
+    get leafSecrets() {
+        const ret = wasm.addmemberupdate_leafSecrets(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         }
+        return v1;
     }
 }
-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));
+if (Symbol.dispose) AddMemberUpdate.prototype[Symbol.dispose] = AddMemberUpdate.prototype.free;
 
 export class Agent {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Agent.prototype);
         obj.__wbg_ptr = ptr;
         AgentFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         AgentFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_agent_free(ptr, 0);
     }
+    /**
+     * @returns {Identifier}
+     */
+    get id() {
+        const ret = wasm.agent_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isDocument() {
+        const ret = wasm.agent_isDocument(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isGroup() {
+        const ret = wasm.agent_isGroup(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isIndividual() {
+        const ret = wasm.agent_isIndividual(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns prekey operation hashes for this [`Agent`] as an array of hash bytes.
+     * @returns {Promise<Uint8Array[]>}
+     */
+    keyOpHashes() {
+        const ret = wasm.agent_keyOpHashes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns prekey operations for this agent as a Map of hash -> serialized bytes for [`StaticEvent`]
+     * @returns {Promise<Map<any, any>>}
+     */
+    keyOps() {
+        const ret = wasm.agent_keyOps(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {string}
      */
@@ -413,76 +168,101 @@ export class Agent {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+}
+if (Symbol.dispose) Agent.prototype[Symbol.dispose] = Agent.prototype.free;
+
+/**
+ * Result of [`JsKeyhive::all_agent_events`], containing all events for all agents
+ * with deduplicated storage and two-tier indirection for membership, prekey, and CGKA ops.
+ *
+ * The consumer follows: agent -> source IDs -> hashes -> event bytes.
+ */
+export class AllAgentEvents {
+    static __wrap(ptr) {
+        const obj = Object.create(AllAgentEvents.prototype);
+        obj.__wbg_ptr = ptr;
+        AllAgentEventsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AllAgentEventsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_allagentevents_free(ptr, 0);
+    }
     /**
-     * @returns {boolean}
+     * @returns {Map<any, any>}
      */
-    isIndividual() {
-        const ret = wasm.agent_isIndividual(this.__wbg_ptr);
-        return ret !== 0;
+    get agentCgkaSources() {
+        const ret = wasm.allagentevents_agentCgkaSources(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @returns {boolean}
+     * @returns {Map<any, any>}
      */
-    isGroup() {
-        const ret = wasm.agent_isGroup(this.__wbg_ptr);
-        return ret !== 0;
+    get agentMembershipSources() {
+        const ret = wasm.allagentevents_agentMembershipSources(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @returns {boolean}
+     * @returns {Map<any, any>}
      */
-    isDocument() {
-        const ret = wasm.agent_isDocument(this.__wbg_ptr);
-        return ret !== 0;
+    get agentPrekeySources() {
+        const ret = wasm.allagentevents_agentPrekeySources(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @returns {Identifier}
+     * @returns {Map<any, any>}
      */
-    get id() {
-        const ret = wasm.agent_id(this.__wbg_ptr);
-        return Identifier.__wrap(ret);
+    get cgkaSources() {
+        const ret = wasm.allagentevents_cgkaSources(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Map<any, any>}
+     */
+    get events() {
+        const ret = wasm.allagentevents_events(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Map<any, any>}
+     */
+    get membershipSources() {
+        const ret = wasm.allagentevents_membershipSources(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Map<any, any>}
+     */
+    get prekeySources() {
+        const ret = wasm.allagentevents_prekeySources(this.__wbg_ptr);
+        return ret;
     }
 }
-if (Symbol.dispose) Agent.prototype[Symbol.dispose] = Agent.prototype.free;
-
-const ArchiveFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_archive_free(ptr >>> 0, 1));
+if (Symbol.dispose) AllAgentEvents.prototype[Symbol.dispose] = AllAgentEvents.prototype.free;
 
 export class Archive {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Archive.prototype);
         obj.__wbg_ptr = ptr;
         ArchiveFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         ArchiveFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_archive_free(ptr, 0);
     }
-    /**
-     * @param {Uint8Array} bytes
-     */
-    constructor(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.archive_try_from_bytes(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        ArchiveFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * @returns {Uint8Array}
      */
@@ -499,42 +279,45 @@ 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);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.archive_try_from_bytes(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return Keyhive.__wrap(ret[0]);
+        this.__wbg_ptr = ret[0];
+        ArchiveFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
 }
 if (Symbol.dispose) Archive.prototype[Symbol.dispose] = Archive.prototype.free;
 
-const CannotParseEd25519SigningKeyFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_cannotparseed25519signingkey_free(ptr >>> 0, 1));
-
 export class CannotParseEd25519SigningKey {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(CannotParseEd25519SigningKey.prototype);
         obj.__wbg_ptr = ptr;
         CannotParseEd25519SigningKeyFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         CannotParseEd25519SigningKeyFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_cannotparseed25519signingkey_free(ptr, 0);
@@ -542,27 +325,19 @@ export class CannotParseEd25519SigningKey {
 }
 if (Symbol.dispose) CannotParseEd25519SigningKey.prototype[Symbol.dispose] = CannotParseEd25519SigningKey.prototype.free;
 
-const CannotParseIdentifierFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_cannotparseidentifier_free(ptr >>> 0, 1));
-
 export class CannotParseIdentifier {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(CannotParseIdentifier.prototype);
         obj.__wbg_ptr = ptr;
         CannotParseIdentifierFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         CannotParseIdentifierFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_cannotparseidentifier_free(ptr, 0);
@@ -570,38 +345,23 @@ export class CannotParseIdentifier {
 }
 if (Symbol.dispose) CannotParseIdentifier.prototype[Symbol.dispose] = CannotParseIdentifier.prototype.free;
 
-const CapabilityFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_capability_free(ptr >>> 0, 1));
-
 export class Capability {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Capability.prototype);
         obj.__wbg_ptr = ptr;
         CapabilityFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         CapabilityFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_capability_free(ptr, 0);
     }
-    /**
-     * @returns {Agent}
-     */
-    get who() {
-        const ret = wasm.capability_who(this.__wbg_ptr);
-        return Agent.__wrap(ret);
-    }
     /**
      * @returns {Access}
      */
@@ -616,30 +376,29 @@ export class Capability {
         const ret = wasm.capability_proof(this.__wbg_ptr);
         return SignedDelegation.__wrap(ret);
     }
+    /**
+     * @returns {Agent}
+     */
+    get who() {
+        const ret = wasm.capability_who(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
 }
 if (Symbol.dispose) Capability.prototype[Symbol.dispose] = Capability.prototype.free;
 
-const CgkaOperationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_cgkaoperation_free(ptr >>> 0, 1));
-
 export class CgkaOperation {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(CgkaOperation.prototype);
         obj.__wbg_ptr = ptr;
         CgkaOperationFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         CgkaOperationFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_cgkaoperation_free(ptr, 0);
@@ -662,136 +421,146 @@ export class CgkaOperation {
 }
 if (Symbol.dispose) CgkaOperation.prototype[Symbol.dispose] = CgkaOperation.prototype.free;
 
-const ChangeRefFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_changeref_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();
     }
-
     __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
+     * Upcasts; to the JS-import type for [`JsChangeId`].
+     * @returns {ChangeId}
      */
-    constructor(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.changeref_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        ChangeRefFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    __wasm_refgen_toJsChangeId() {
+        const ret = wasm.changeid___wasm_refgen_toJsChangeId(this.__wbg_ptr);
+        return ChangeId.__wrap(ret);
     }
     /**
      * @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;
     }
+    /**
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.changeid_new(ptr0, len0);
+        this.__wbg_ptr = ret;
+        ChangeIdFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
 }
-if (Symbol.dispose) ChangeRef.prototype[Symbol.dispose] = ChangeRef.prototype.free;
-
-const CiphertextStoreFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ciphertextstore_free(ptr >>> 0, 1));
+if (Symbol.dispose) ChangeId.prototype[Symbol.dispose] = ChangeId.prototype.free;
 
 export class CiphertextStore {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(CiphertextStore.prototype);
         obj.__wbg_ptr = ptr;
         CiphertextStoreFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         CiphertextStoreFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_ciphertextstore_free(ptr, 0);
     }
     /**
+     * @param {Storage} storage
      * @returns {CiphertextStore}
      */
-    static newInMemory() {
-        const ret = wasm.ciphertextstore_newInMemory();
+    static newFromWebStorage(storage) {
+        const ret = wasm.ciphertextstore_newFromWebStorage(storage);
         return CiphertextStore.__wrap(ret);
     }
     /**
-     * @param {Storage} storage
      * @returns {CiphertextStore}
      */
-    static newFromWebStorage(storage) {
-        const ret = wasm.ciphertextstore_newFromWebStorage(storage);
+    static newInMemory() {
+        const ret = wasm.ciphertextstore_newInMemory();
         return CiphertextStore.__wrap(ret);
     }
 }
 if (Symbol.dispose) CiphertextStore.prototype[Symbol.dispose] = CiphertextStore.prototype.free;
 
-const ContactCardFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_contactcard_free(ptr >>> 0, 1));
-
 export class ContactCard {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(ContactCard.prototype);
         obj.__wbg_ptr = ptr;
         ContactCardFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         ContactCardFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_contactcard_free(ptr, 0);
     }
     /**
-     * @returns {IndividualId}
+     * @param {string} json
+     * @returns {ContactCard}
+     */
+    static fromJson(json) {
+        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.contactcard_fromJson(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContactCard.__wrap(ret[0]);
+    }
+    /**
+     * @returns {Identifier}
      */
     get id() {
         const ret = wasm.contactcard_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {IndividualId}
+     */
+    get individualId() {
+        const ret = wasm.contactcard_individualId(this.__wbg_ptr);
         return IndividualId.__wrap(ret);
     }
+    /**
+     * @returns {Event}
+     */
+    get op() {
+        const ret = wasm.contactcard_op(this.__wbg_ptr);
+        return Event.__wrap(ret);
+    }
     /**
      * @returns {ShareKey}
      */
@@ -808,19 +577,6 @@ export class ContactCard {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
-    /**
-     * @param {string} json
-     * @returns {ContactCard}
-     */
-    static fromJson(json) {
-        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.contactcard_fromJson(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ContactCard.__wrap(ret[0]);
-    }
     /**
      * @returns {string}
      */
@@ -845,37 +601,29 @@ export class ContactCard {
 }
 if (Symbol.dispose) ContactCard.prototype[Symbol.dispose] = ContactCard.prototype.free;
 
-const DelegationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_delegation_free(ptr >>> 0, 1));
-
 export class Delegation {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Delegation.prototype);
         obj.__wbg_ptr = ptr;
         DelegationFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         DelegationFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_delegation_free(ptr, 0);
     }
     /**
-     * @returns {Agent}
+     * @returns {History}
      */
-    get delegate() {
-        const ret = wasm.delegation_delegate(this.__wbg_ptr);
-        return Agent.__wrap(ret);
+    get after() {
+        const ret = wasm.delegation_after(this.__wbg_ptr);
+        return History.__wrap(ret);
     }
     /**
      * @returns {Access}
@@ -884,6 +632,13 @@ export class Delegation {
         const ret = wasm.delegation_can(this.__wbg_ptr);
         return Access.__wrap(ret);
     }
+    /**
+     * @returns {Agent}
+     */
+    get delegate() {
+        const ret = wasm.delegation_delegate(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
     /**
      * @returns {SignedDelegation | undefined}
      */
@@ -891,85 +646,42 @@ export class Delegation {
         const ret = wasm.delegation_proof(this.__wbg_ptr);
         return ret === 0 ? undefined : SignedDelegation.__wrap(ret);
     }
-    /**
-     * @returns {History}
-     */
-    get after() {
-        const ret = wasm.delegation_after(this.__wbg_ptr);
-        return History.__wrap(ret);
-    }
 }
 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));
-
 export class DocContentRefs {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(DocContentRefs.prototype);
         obj.__wbg_ptr = ptr;
         DocContentRefsFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         DocContentRefsFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_doccontentrefs_free(ptr, 0);
     }
     /**
-     * @param {DocumentId} doc_id
-     * @param {ChangeRef[]} change_hashes
+     * @param {ChangeId} hash
+     * @returns {Promise<void>}
      */
-    constructor(doc_id, change_hashes) {
-        _assertClass(doc_id, DocumentId);
-        var ptr0 = doc_id.__destroy_into_raw();
-        const ptr1 = passArrayJsValueToWasm0(change_hashes, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.doccontentrefs_new(ptr0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        DocContentRefsFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    addChangeId(hash) {
+        _assertClass(hash, ChangeId);
+        var ptr0 = hash.__destroy_into_raw();
+        const ret = wasm.doccontentrefs_addChangeId(this.__wbg_ptr, ptr0);
+        return ret;
     }
     /**
-     * @param {ChangeRef} hash
+     * @returns {Promise<ChangeId[]>}
      */
-    addChangeRef(hash) {
-        _assertClass(hash, ChangeRef);
-        var ptr0 = hash.__destroy_into_raw();
-        wasm.doccontentrefs_addChangeRef(this.__wbg_ptr, ptr0);
+    get change_hashes() {
+        const ret = wasm.doccontentrefs_change_hashes(this.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {DocumentId}
@@ -979,55 +691,49 @@ export class DocContentRefs {
         return DocumentId.__wrap(ret);
     }
     /**
-     * @returns {ChangeRef[]}
+     * @param {DocumentId} doc_id
+     * @param {ChangeId[]} change_hashes
      */
-    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;
+    constructor(doc_id, change_hashes) {
+        _assertClass(doc_id, DocumentId);
+        var ptr0 = doc_id.__destroy_into_raw();
+        const ptr1 = passArrayJsValueToWasm0(change_hashes, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.doccontentrefs_new(ptr0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        DocContentRefsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
 }
 if (Symbol.dispose) DocContentRefs.prototype[Symbol.dispose] = DocContentRefs.prototype.free;
 
-const DocumentFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_document_free(ptr >>> 0, 1));
-
 export class Document {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Document.prototype);
         obj.__wbg_ptr = ptr;
         DocumentFinalization.register(obj, obj.__wbg_ptr, obj);
         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;
         DocumentFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_document_free(ptr, 0);
     }
     /**
-     * @returns {Identifier}
+     * Upcasts; to the JS-import type for [`JsDocument`].
+     * @returns {Document}
      */
-    get id() {
-        const ret = wasm.document_id(this.__wbg_ptr);
-        return Identifier.__wrap(ret);
+    __wasm_refgen_toJsDocument() {
+        const ret = wasm.document___wasm_refgen_toJsDocument(this.__wbg_ptr);
+        return Document.__wrap(ret);
     }
     /**
      * @returns {DocumentId}
@@ -1037,11 +743,18 @@ export class Document {
         return DocumentId.__wrap(ret);
     }
     /**
-     * @returns {Peer}
+     * @returns {Identifier}
      */
-    toPeer() {
-        const ret = wasm.document_toPeer(this.__wbg_ptr);
-        return Peer.__wrap(ret);
+    get id() {
+        const ret = wasm.document_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {Promise<Capability[]>}
+     */
+    members() {
+        const ret = wasm.document_members(this.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {Agent}
@@ -1057,30 +770,29 @@ export class Document {
         const ret = wasm.document_toMembered(this.__wbg_ptr);
         return Membered.__wrap(ret);
     }
+    /**
+     * @returns {Peer}
+     */
+    toPeer() {
+        const ret = wasm.document_toPeer(this.__wbg_ptr);
+        return Peer.__wrap(ret);
+    }
 }
 if (Symbol.dispose) Document.prototype[Symbol.dispose] = Document.prototype.free;
 
-const DocumentIdFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_documentid_free(ptr >>> 0, 1));
-
 export class DocumentId {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(DocumentId.prototype);
         obj.__wbg_ptr = ptr;
         DocumentIdFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         DocumentIdFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_documentid_free(ptr, 0);
@@ -1095,10 +807,26 @@ export class DocumentId {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
+        this.__wbg_ptr = ret[0];
         DocumentIdFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.documentid_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {any}
+     */
+    toJsValue() {
+        const ret = wasm.documentid_toJsValue(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {string}
      */
@@ -1114,46 +842,22 @@ export class DocumentId {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * @returns {any}
-     */
-    toJsValue() {
-        const ret = wasm.documentid_toJsValue(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    toBytes() {
-        const ret = wasm.documentid_toBytes(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
 }
 if (Symbol.dispose) DocumentId.prototype[Symbol.dispose] = DocumentId.prototype.free;
 
-const EncryptedFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_encrypted_free(ptr >>> 0, 1));
-
 export class Encrypted {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Encrypted.prototype);
         obj.__wbg_ptr = ptr;
         EncryptedFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         EncryptedFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_encrypted_free(ptr, 0);
@@ -1161,8 +865,8 @@ export class Encrypted {
     /**
      * @returns {Uint8Array}
      */
-    toBytes() {
-        const ret = wasm.encrypted_toBytes(this.__wbg_ptr);
+    get ciphertext() {
+        const ret = wasm.encrypted_ciphertext(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -1170,12 +874,25 @@ export class Encrypted {
     /**
      * @returns {Uint8Array}
      */
-    get ciphertext() {
-        const ret = wasm.encrypted_ciphertext(this.__wbg_ptr);
+    get content_ref() {
+        const ret = wasm.encrypted_content_ref(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {Encrypted}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.encrypted_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Encrypted.__wrap(ret[0]);
+    }
     /**
      * @returns {Uint8Array}
      */
@@ -1197,8 +914,8 @@ export class Encrypted {
     /**
      * @returns {Uint8Array}
      */
-    get content_ref() {
-        const ret = wasm.encrypted_content_ref(this.__wbg_ptr);
+    get pred_refs() {
+        const ret = wasm.encrypted_pred_refs(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -1206,8 +923,20 @@ export class Encrypted {
     /**
      * @returns {Uint8Array}
      */
-    get pred_refs() {
-        const ret = wasm.encrypted_pred_refs(this.__wbg_ptr);
+    serialize() {
+        const ret = wasm.encrypted_serialize(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;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.encrypted_toBytes(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -1215,27 +944,19 @@ export class Encrypted {
 }
 if (Symbol.dispose) Encrypted.prototype[Symbol.dispose] = Encrypted.prototype.free;
 
-const EncryptedContentWithUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_encryptedcontentwithupdate_free(ptr >>> 0, 1));
-
 export class EncryptedContentWithUpdate {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(EncryptedContentWithUpdate.prototype);
         obj.__wbg_ptr = ptr;
         EncryptedContentWithUpdateFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         EncryptedContentWithUpdateFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_encryptedcontentwithupdate_free(ptr, 0);
@@ -1257,46 +978,23 @@ export class EncryptedContentWithUpdate {
 }
 if (Symbol.dispose) EncryptedContentWithUpdate.prototype[Symbol.dispose] = EncryptedContentWithUpdate.prototype.free;
 
-const EventFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_event_free(ptr >>> 0, 1));
-
 export class Event {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Event.prototype);
         obj.__wbg_ptr = ptr;
         EventFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         EventFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_event_free(ptr, 0);
     }
-    /**
-     * @returns {string}
-     */
-    get variant() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.event_variant(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);
-        }
-    }
     /**
      * @returns {boolean}
      */
@@ -1311,6 +1009,20 @@ export class Event {
         const ret = wasm.event_isRevoked(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Converts the underlying [`Event`] to a [`StaticEvent`] and then
+     * serializes it.
+     * @returns {Uint8Array}
+     */
+    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;
+    }
     /**
      * @returns {SignedDelegation | undefined}
      */
@@ -1325,42 +1037,14 @@ 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}
      */
-    message() {
+    get variant() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.generatedocerror_message(this.__wbg_ptr);
+            const ret = wasm.event_variant(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -1369,29 +1053,21 @@ export class GenerateDocError {
         }
     }
 }
-if (Symbol.dispose) GenerateDocError.prototype[Symbol.dispose] = GenerateDocError.prototype.free;
-
-const GenerateWebCryptoErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_generatewebcryptoerror_free(ptr >>> 0, 1));
+if (Symbol.dispose) Event.prototype[Symbol.dispose] = Event.prototype.free;
 
 export class GenerateWebCryptoError {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(GenerateWebCryptoError.prototype);
         obj.__wbg_ptr = ptr;
         GenerateWebCryptoErrorFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         GenerateWebCryptoErrorFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_generatewebcryptoerror_free(ptr, 0);
@@ -1414,72 +1090,30 @@ 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));
-
 export class Group {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Group.prototype);
         obj.__wbg_ptr = ptr;
         GroupFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         GroupFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_group_free(ptr, 0);
     }
     /**
-     * @returns {Identifier}
+     * Upcasts; to the JS-import type for [`JsGroup`].
+     * @returns {Group}
      */
-    get id() {
-        const ret = wasm.group_id(this.__wbg_ptr);
-        return Identifier.__wrap(ret);
+    __wasm_refgen_toJsGroup() {
+        const ret = wasm.group___wasm_refgen_toJsGroup(this.__wbg_ptr);
+        return Group.__wrap(ret);
     }
     /**
      * @returns {GroupId}
@@ -1489,20 +1123,18 @@ export class Group {
         return GroupId.__wrap(ret);
     }
     /**
-     * @returns {Capability[]}
+     * @returns {Identifier}
      */
-    get 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;
+    get id() {
+        const ret = wasm.group_id(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
     }
     /**
-     * @returns {Peer}
+     * @returns {Promise<Capability[]>}
      */
-    toPeer() {
-        const ret = wasm.group_toPeer(this.__wbg_ptr);
-        return Peer.__wrap(ret);
+    members() {
+        const ret = wasm.group_members(this.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {Agent}
@@ -1518,30 +1150,29 @@ export class Group {
         const ret = wasm.group_toMembered(this.__wbg_ptr);
         return Membered.__wrap(ret);
     }
+    /**
+     * @returns {Peer}
+     */
+    toPeer() {
+        const ret = wasm.group_toPeer(this.__wbg_ptr);
+        return Peer.__wrap(ret);
+    }
 }
 if (Symbol.dispose) Group.prototype[Symbol.dispose] = Group.prototype.free;
 
-const GroupIdFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_groupid_free(ptr >>> 0, 1));
-
 export class GroupId {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(GroupId.prototype);
         obj.__wbg_ptr = ptr;
         GroupIdFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         GroupIdFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_groupid_free(ptr, 0);
@@ -1564,54 +1195,46 @@ export class GroupId {
 }
 if (Symbol.dispose) GroupId.prototype[Symbol.dispose] = GroupId.prototype.free;
 
-const HistoryFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_history_free(ptr >>> 0, 1));
-
 export class History {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(History.prototype);
         obj.__wbg_ptr = ptr;
         HistoryFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         HistoryFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_history_free(ptr, 0);
     }
     /**
-     * @returns {SignedDelegation[]}
+     * @returns {DocContentRefs[]}
      */
-    delegations() {
-        const ret = wasm.history_delegations(this.__wbg_ptr);
+    contentRefs() {
+        const ret = wasm.history_contentRefs(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
     /**
-     * @returns {SignedRevocation[]}
+     * @returns {SignedDelegation[]}
      */
-    revocations() {
-        const ret = wasm.history_revocations(this.__wbg_ptr);
+    delegations() {
+        const ret = wasm.history_delegations(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
     /**
-     * @returns {DocContentRefs[]}
+     * @returns {SignedRevocation[]}
      */
-    contentRefs() {
-        const ret = wasm.history_contentRefs(this.__wbg_ptr);
+    revocations() {
+        const ret = wasm.history_revocations(this.__wbg_ptr);
         var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
@@ -1619,27 +1242,19 @@ export class History {
 }
 if (Symbol.dispose) History.prototype[Symbol.dispose] = History.prototype.free;
 
-const IdentifierFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_identifier_free(ptr >>> 0, 1));
-
 export class Identifier {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Identifier.prototype);
         obj.__wbg_ptr = ptr;
         IdentifierFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         IdentifierFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_identifier_free(ptr, 0);
@@ -1654,10 +1269,17 @@ export class Identifier {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        this.__wbg_ptr = ret[0] >>> 0;
+        this.__wbg_ptr = ret[0];
         IdentifierFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @returns {Identifier}
+     */
+    static publicId() {
+        const ret = wasm.identifier_publicId();
+        return Identifier.__wrap(ret);
+    }
     /**
      * @returns {Uint8Array}
      */
@@ -1670,45 +1292,23 @@ export class Identifier {
 }
 if (Symbol.dispose) Identifier.prototype[Symbol.dispose] = Identifier.prototype.free;
 
-const IndividualFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_individual_free(ptr >>> 0, 1));
-
 export class Individual {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Individual.prototype);
         obj.__wbg_ptr = ptr;
         IndividualFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         IndividualFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_individual_free(ptr, 0);
     }
-    /**
-     * @returns {Peer}
-     */
-    toPeer() {
-        const ret = wasm.individual_toPeer(this.__wbg_ptr);
-        return Peer.__wrap(ret);
-    }
-    /**
-     * @returns {Agent}
-     */
-    toAgent() {
-        const ret = wasm.individual_toAgent(this.__wbg_ptr);
-        return Agent.__wrap(ret);
-    }
     /**
      * @returns {Identifier}
      */
@@ -1725,38 +1325,44 @@ export class Individual {
     }
     /**
      * @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;
+    }
+    /**
+     * @returns {Agent}
+     */
+    toAgent() {
+        const ret = wasm.individual_toAgent(this.__wbg_ptr);
+        return Agent.__wrap(ret);
+    }
+    /**
+     * @returns {Peer}
+     */
+    toPeer() {
+        const ret = wasm.individual_toPeer(this.__wbg_ptr);
+        return Peer.__wrap(ret);
     }
 }
 if (Symbol.dispose) Individual.prototype[Symbol.dispose] = Individual.prototype.free;
 
-const IndividualIdFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_individualid_free(ptr >>> 0, 1));
-
 export class IndividualId {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(IndividualId.prototype);
         obj.__wbg_ptr = ptr;
         IndividualIdFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         IndividualIdFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_individualid_free(ptr, 0);
@@ -1773,19 +1379,13 @@ export class IndividualId {
 }
 if (Symbol.dispose) IndividualId.prototype[Symbol.dispose] = IndividualId.prototype.free;
 
-const InvocationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_invocation_free(ptr >>> 0, 1));
-
 export class Invocation {
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         InvocationFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_invocation_free(ptr, 0);
@@ -1793,177 +1393,199 @@ 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 {
-
+export class Keyhive {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(JsDecryptError.prototype);
+        const obj = Object.create(Keyhive.prototype);
         obj.__wbg_ptr = ptr;
-        JsDecryptErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        KeyhiveFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        JsDecryptErrorFinalization.unregister(this);
+        KeyhiveFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsdecrypterror_free(ptr, 0);
+        wasm.__wbg_keyhive_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;
+    /**
+     * @param {Identifier} id
+     * @param {DocumentId} doc_id
+     * @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;
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsEncryptErrorFinalization.unregister(this);
-        return ptr;
+    /**
+     * @param {Agent} to_add
+     * @param {Membered} membered
+     * @param {Access} access
+     * @param {Document[]} other_relevant_docs
+     * @returns {Promise<AddMemberUpdate>}
+     */
+    addMember(to_add, membered, access, other_relevant_docs) {
+        _assertClass(to_add, Agent);
+        _assertClass(membered, Membered);
+        _assertClass(access, Access);
+        const ptr0 = passArrayJsValueToWasm0(other_relevant_docs, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_addMember(this.__wbg_ptr, to_add.__wbg_ptr, membered.__wbg_ptr, access.__wbg_ptr, ptr0, len0);
+        return ret;
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsencrypterror_free(ptr, 0);
+    /**
+     * Returns all agent events with deduplicated storage and two-tier indirection
+     * for membership, prekey, and CGKA ops.
+     * @returns {Promise<AllAgentEvents>}
+     */
+    allAgentEvents() {
+        const ret = wasm.keyhive_allAgentEvents(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<ContactCard>}
+     */
+    contactCard() {
+        const ret = wasm.keyhive_contactCard(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {DocumentId} doc_id
+     * @returns {Promise<Membership[]>}
+     */
+    docMemberCapabilities(doc_id) {
+        _assertClass(doc_id, DocumentId);
+        const ret = wasm.keyhive_docMemberCapabilities(this.__wbg_ptr, doc_id.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Returns event hashes for provided [`JsAgent`] as an array of hash bytes.
+     * @param {Agent} agent
+     * @returns {Promise<Array<any>>}
+     */
+    eventHashesForAgent(agent) {
+        _assertClass(agent, Agent);
+        const ret = wasm.keyhive_eventHashesForAgent(this.__wbg_ptr, agent.__wbg_ptr);
+        return ret;
     }
-}
-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;
+    /**
+     * Returns events for provided [`Agent`] as a map from hash to serialized [`StaticEvent`] bytes.
+     * @param {Agent} agent
+     * @returns {Promise<Map<any, any>>}
+     */
+    eventsForAgent(agent) {
+        _assertClass(agent, Agent);
+        const ret = wasm.keyhive_eventsForAgent(this.__wbg_ptr, agent.__wbg_ptr);
+        return ret;
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsReceivePreKeyOpErrorFinalization.unregister(this);
-        return ptr;
+    /**
+     * @returns {Promise<ShareKey>}
+     */
+    expandPrekeys() {
+        const ret = wasm.keyhive_expandPrekeys(this.__wbg_ptr);
+        return ret;
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsreceiveprekeyoperror_free(ptr, 0);
+    /**
+     * @returns {Promise<Uint8Array>}
+     */
+    exportPrekeySecrets() {
+        const ret = wasm.keyhive_exportPrekeySecrets(this.__wbg_ptr);
+        return ret;
     }
-}
-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;
+    /**
+     * Force a PCS key rotation and return the new leaf secret, serialized as a
+     * one-entry `BTreeMap<ShareKey, ShareSecretKey>` (the exact format
+     * `importPrekeySecrets` accepts). A sibling instance of this identity can
+     * install it to derive the rotated key without re-importing the whole bundle.
+     * @param {Document} doc
+     * @returns {Promise<Uint8Array>}
+     */
+    forcePcsUpdate(doc) {
+        _assertClass(doc, Document);
+        const ret = wasm.keyhive_forcePcsUpdate(this.__wbg_ptr, doc.__wbg_ptr);
+        return ret;
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        JsReceiveStaticEventErrorFinalization.unregister(this);
-        return ptr;
+    /**
+     * Generate a document. Whether it provides forward secrecy is determined by
+     * this peer's forward-secrecy policy (chosen at `Keyhive.init`).
+     * @param {Peer[]} coparents
+     * @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, ChangeId);
+        const ptr1 = passArrayJsValueToWasm0(more_initial_content_refs, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_generateDocument(this.__wbg_ptr, ptr0, len0, initial_content_ref_head.__wbg_ptr, ptr1, len1);
+        return ret;
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_jsreceivestaticeventerror_free(ptr, 0);
+    /**
+     * @param {Peer[]} js_coparents
+     * @returns {Promise<Group>}
+     */
+    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;
     }
-}
-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));
-
-export class Keyhive {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Keyhive.prototype);
-        obj.__wbg_ptr = ptr;
-        KeyhiveFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+    /**
+     * @param {Identifier} id
+     * @returns {Promise<Agent | undefined>}
+     */
+    getAgent(id) {
+        _assertClass(id, Identifier);
+        const ret = wasm.keyhive_getAgent(this.__wbg_ptr, id.__wbg_ptr);
+        return ret;
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        KeyhiveFinalization.unregister(this);
-        return ptr;
+    /**
+     * @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;
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_keyhive_free(ptr, 0);
+    /**
+     * @returns {Promise<ContactCard>}
+     */
+    getExistingContactCard() {
+        const ret = wasm.keyhive_getExistingContactCard(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * @param {Signer} signer
-     * @param {CiphertextStore} ciphertext_store
-     * @param {Function} event_handler
-     * @returns {Promise<Keyhive>}
+     * @param {GroupId} group_id
+     * @returns {Promise<Group | undefined>}
      */
-    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);
+    getGroup(group_id) {
+        _assertClass(group_id, GroupId);
+        const ret = wasm.keyhive_getGroup(this.__wbg_ptr, group_id.__wbg_ptr);
         return ret;
     }
     /**
-     * @returns {IndividualId}
+     * @param {IndividualId} id
+     * @returns {Promise<Individual | undefined>}
      */
-    get id() {
-        const ret = wasm.keyhive_id(this.__wbg_ptr);
-        return IndividualId.__wrap(ret);
+    getIndividual(id) {
+        _assertClass(id, IndividualId);
+        const ret = wasm.keyhive_getIndividual(this.__wbg_ptr, id.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {IndividualId}
      */
-    get whoami() {
+    get id() {
         const ret = wasm.keyhive_id(this.__wbg_ptr);
         return IndividualId.__wrap(ret);
     }
-    /**
-     * @returns {Individual}
-     */
-    get individual() {
-        const ret = wasm.keyhive_individual(this.__wbg_ptr);
-        return Individual.__wrap(ret);
-    }
     /**
      * @returns {string}
      */
@@ -1980,108 +1602,97 @@ export class Keyhive {
         }
     }
     /**
-     * @param {Peer[]} coparents
-     * @returns {Promise<Group>}
+     * @param {Uint8Array} bytes
+     * @returns {Promise<void>}
      */
-    generateGroup(coparents) {
-        const ptr0 = passArrayJsValueToWasm0(coparents, wasm.__wbindgen_malloc);
+    importPrekeySecrets(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.keyhive_generateGroup(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.keyhive_importPrekeySecrets(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
-     * @param {Peer[]} coparents
-     * @param {ChangeRef} initial_content_ref_head
-     * @param {ChangeRef[]} more_initial_content_refs
-     * @returns {Promise<Document>}
+     * @returns {Promise<Individual>}
      */
-    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);
-        var ptr1 = initial_content_ref_head.__destroy_into_raw();
-        const ptr2 = passArrayJsValueToWasm0(more_initial_content_refs, wasm.__wbindgen_malloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.keyhive_generateDocument(this.__wbg_ptr, ptr0, len0, ptr1, ptr2, len2);
+    get individual() {
+        const ret = wasm.keyhive_individual(this.__wbg_ptr);
         return ret;
     }
     /**
-     * @param {Uint8Array} data
-     * @returns {Promise<Signed>}
+     * @param {Archive} archive
+     * @returns {Promise<void>}
      */
-    trySign(data) {
-        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.keyhive_trySign(this.__wbg_ptr, ptr0, len0);
+    ingestArchive(archive) {
+        _assertClass(archive, Archive);
+        const ret = wasm.keyhive_ingestArchive(this.__wbg_ptr, archive.__wbg_ptr);
         return ret;
     }
     /**
-     * @param {Document} doc
-     * @param {ChangeRef} content_ref
-     * @param {ChangeRef[]} pred_refs
-     * @param {Uint8Array} content
-     * @returns {Promise<EncryptedContentWithUpdate>}
+     * @param {Array<any>} events_bytes_array
+     * @returns {Promise<Array<any>>}
      */
-    tryEncrypt(doc, content_ref, pred_refs, content) {
-        _assertClass(doc, Document);
-        _assertClass(content_ref, ChangeRef);
-        var ptr0 = content_ref.__destroy_into_raw();
-        const ptr1 = passArrayJsValueToWasm0(pred_refs, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArray8ToWasm0(content, wasm.__wbindgen_malloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.keyhive_tryEncrypt(this.__wbg_ptr, doc.__wbg_ptr, ptr0, ptr1, len1, ptr2, len2);
+    ingestEventsBytes(events_bytes_array) {
+        const ret = wasm.keyhive_ingestEventsBytes(this.__wbg_ptr, events_bytes_array);
         return ret;
     }
     /**
-     * @param {Document} doc
-     * @param {ChangeRef} content_ref
-     * @param {ChangeRef[]} pred_refs
-     * @param {Uint8Array} content
-     * @returns {Promise<EncryptedContentWithUpdate>}
+     * Initialize a peer.
+     *
+     * `forward_secrecy` is this peer's policy for all documents it creates or
+     * receives. When `false`, documents carry the CGKA predecessor key chain
+     * (a member added later reads the whole prior history) and adding a reader
+     * auto-rekeys (see `addMember`'s `leafSecrets`). When `true`, a member
+     * added later cannot read content from before they joined.
+     * @param {Signer} signer
+     * @param {CiphertextStore} ciphertext_store
+     * @param {Function} event_handler
+     * @param {boolean} forward_secrecy
+     * @returns {Promise<Keyhive>}
      */
-    tryEncryptArchive(doc, content_ref, pred_refs, content) {
-        _assertClass(doc, Document);
-        _assertClass(content_ref, ChangeRef);
-        var ptr0 = content_ref.__destroy_into_raw();
-        const ptr1 = passArrayJsValueToWasm0(pred_refs, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArray8ToWasm0(content, wasm.__wbindgen_malloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.keyhive_tryEncryptArchive(this.__wbg_ptr, doc.__wbg_ptr, ptr0, ptr1, len1, ptr2, len2);
+    static init(signer, ciphertext_store, event_handler, forward_secrecy) {
+        _assertClass(signer, Signer);
+        _assertClass(ciphertext_store, CiphertextStore);
+        const ret = wasm.keyhive_init(signer.__wbg_ptr, ciphertext_store.__wbg_ptr, event_handler, forward_secrecy);
         return ret;
     }
     /**
-     * @param {Document} doc
-     * @param {Encrypted} encrypted
-     * @returns {Uint8Array}
+     * @returns {Promise<Archive>}
      */
-    tryDecrypt(doc, encrypted) {
-        _assertClass(doc, Document);
-        _assertClass(encrypted, Encrypted);
-        const ret = wasm.keyhive_tryDecrypt(this.__wbg_ptr, doc.__wbg_ptr, encrypted.__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;
+    intoArchive() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.keyhive_intoArchive(ptr);
+        return ret;
     }
     /**
-     * @param {Agent} to_add
-     * @param {Membered} membered
-     * @param {Access} access
-     * @param {Document[]} other_relevant_docs
-     * @returns {Promise<SignedDelegation>}
+     * @param {Agent} agent
+     * @returns {Promise<Map<any, any>>}
      */
-    addMember(to_add, membered, access, other_relevant_docs) {
-        _assertClass(to_add, Agent);
-        _assertClass(membered, Membered);
-        _assertClass(access, Access);
-        var ptr0 = access.__destroy_into_raw();
-        const ptr1 = passArrayJsValueToWasm0(other_relevant_docs, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.keyhive_addMember(this.__wbg_ptr, to_add.__wbg_ptr, membered.__wbg_ptr, ptr0, ptr1, len1);
+    membershipOpsForAgent(agent) {
+        _assertClass(agent, Agent);
+        const ret = wasm.keyhive_membershipOpsForAgent(this.__wbg_ptr, agent.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<Set<any>>}
+     */
+    pendingEventHashes() {
+        const ret = wasm.keyhive_pendingEventHashes(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {Promise<Summary[]>}
+     */
+    reachableDocs() {
+        const ret = wasm.keyhive_reachableDocs(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {ContactCard} contact_card
+     * @returns {Promise<Individual>}
+     */
+    receiveContactCard(contact_card) {
+        _assertClass(contact_card, ContactCard);
+        const ret = wasm.keyhive_receiveContactCard(this.__wbg_ptr, contact_card.__wbg_ptr);
         return ret;
     }
     /**
@@ -2097,21 +1708,12 @@ export class Keyhive {
         return ret;
     }
     /**
-     * @returns {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;
-    }
-    /**
-     * @param {Document} doc
-     * @returns {Promise<void>}
+     * @param {DocumentId} doc_id
+     * @returns {Promise<Membership[]>}
      */
-    forcePcsUpdate(doc) {
-        _assertClass(doc, Document);
-        const ret = wasm.keyhive_forcePcsUpdate(this.__wbg_ptr, doc.__wbg_ptr);
+    revokedMembersForDoc(doc_id) {
+        _assertClass(doc_id, DocumentId);
+        const ret = wasm.keyhive_revokedMembersForDoc(this.__wbg_ptr, doc_id.__wbg_ptr);
         return ret;
     }
     /**
@@ -2120,133 +1722,110 @@ export class Keyhive {
      */
     rotatePrekey(prekey) {
         _assertClass(prekey, ShareKey);
-        var ptr0 = prekey.__destroy_into_raw();
-        const ret = wasm.keyhive_rotatePrekey(this.__wbg_ptr, ptr0);
+        const ret = wasm.keyhive_rotatePrekey(this.__wbg_ptr, prekey.__wbg_ptr);
         return ret;
     }
     /**
-     * @returns {Promise<ShareKey>}
+     * @returns {Promise<Stats>}
      */
-    expandPrekeys() {
-        const ret = wasm.keyhive_expandPrekeys(this.__wbg_ptr);
+    stats() {
+        const ret = wasm.keyhive_stats(this.__wbg_ptr);
         return ret;
     }
     /**
-     * @returns {Promise<ContactCard>}
+     * @returns {Promise<Archive>}
      */
-    contactCard() {
-        const ret = wasm.keyhive_contactCard(this.__wbg_ptr);
+    toArchive() {
+        const ret = wasm.keyhive_toArchive(this.__wbg_ptr);
         return ret;
     }
     /**
-     * @param {ContactCard} contact_card
-     * @returns {Individual}
-     */
-    receiveContactCard(contact_card) {
-        _assertClass(contact_card, ContactCard);
-        const ret = wasm.keyhive_receiveContactCard(this.__wbg_ptr, contact_card.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Individual.__wrap(ret[0]);
-    }
-    /**
-     * @param {Identifier} id
-     * @returns {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);
-    }
-    /**
-     * @param {Identifier} id
-     * @returns {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);
-    }
-    /**
-     * @param {Identifier} id
-     * @returns {Document | undefined}
+     * @param {Document} doc
+     * @param {Encrypted} encrypted
+     * @returns {Promise<Uint8Array>}
      */
-    getDocument(id) {
-        _assertClass(id, Identifier);
-        const ret = wasm.keyhive_getDocument(this.__wbg_ptr, id.__wbg_ptr);
-        return ret === 0 ? undefined : Document.__wrap(ret);
+    tryDecrypt(doc, encrypted) {
+        _assertClass(doc, Document);
+        _assertClass(encrypted, Encrypted);
+        const ret = wasm.keyhive_tryDecrypt(this.__wbg_ptr, doc.__wbg_ptr, encrypted.__wbg_ptr);
+        return ret;
     }
     /**
-     * @param {DocumentId} doc_id
-     * @returns {SimpleCapability[]}
+     * @param {Document} doc
+     * @param {ChangeId} content_ref
+     * @param {ChangeId[]} js_pred_refs
+     * @param {Uint8Array} content
+     * @returns {Promise<EncryptedContentWithUpdate>}
      */
-    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;
+    tryEncrypt(doc, content_ref, js_pred_refs, content) {
+        _assertClass(doc, Document);
+        _assertClass(content_ref, ChangeId);
+        const ptr0 = passArrayJsValueToWasm0(js_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_tryEncrypt(this.__wbg_ptr, doc.__wbg_ptr, content_ref.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
     }
     /**
-     * @param {Identifier} id
-     * @param {DocumentId} doc_id
-     * @returns {Access | undefined}
+     * @param {Document} doc
+     * @param {ChangeId} content_ref
+     * @param {ChangeId[]} pred_refs
+     * @param {Uint8Array} content
+     * @returns {Promise<EncryptedContentWithUpdate>}
      */
-    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);
+    tryEncryptArchive(doc, content_ref, pred_refs, content) {
+        _assertClass(doc, Document);
+        _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;
     }
     /**
-     * @returns {Archive}
+     * @param {Document} doc
+     * @returns {Promise<Uint8Array | undefined>}
      */
-    intoArchive() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.keyhive_intoArchive(ptr);
-        return Archive.__wrap(ret);
+    tryPcsKeyHash(doc) {
+        _assertClass(doc, Document);
+        const ret = wasm.keyhive_tryPcsKeyHash(this.__wbg_ptr, doc.__wbg_ptr);
+        return ret;
     }
     /**
-     * @returns {Archive}
+     * @param {Uint8Array} data
+     * @returns {Promise<Signed>}
      */
-    toArchive() {
-        const ret = wasm.keyhive_toArchive(this.__wbg_ptr);
-        return Archive.__wrap(ret);
+    trySign(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.keyhive_trySign(this.__wbg_ptr, ptr0, len0);
+        return ret;
     }
     /**
-     * @param {Archive} archive
-     * @returns {Promise<void>}
+     * @returns {IndividualId}
      */
-    ingestArchive(archive) {
-        _assertClass(archive, Archive);
-        const ret = wasm.keyhive_ingestArchive(this.__wbg_ptr, archive.__wbg_ptr);
-        return ret;
+    get whoami() {
+        const ret = wasm.keyhive_whoami(this.__wbg_ptr);
+        return IndividualId.__wrap(ret);
     }
 }
 if (Symbol.dispose) Keyhive.prototype[Symbol.dispose] = Keyhive.prototype.free;
 
-const MemberedFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_membered_free(ptr >>> 0, 1));
-
 export class Membered {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Membered.prototype);
         obj.__wbg_ptr = ptr;
         MemberedFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         MemberedFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_membered_free(ptr, 0);
@@ -2254,186 +1833,101 @@ export class Membered {
 }
 if (Symbol.dispose) Membered.prototype[Symbol.dispose] = Membered.prototype.free;
 
-const PeerFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_peer_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);
-    }
-    /**
-     * @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 {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * @returns {boolean}
-     */
-    isIndividual() {
-        const ret = wasm.peer_isIndividual(this.__wbg_ptr);
-        return ret !== 0;
+        wasm.__wbg_membership_free(ptr, 0);
     }
     /**
-     * @returns {boolean}
+     * @returns {Access}
      */
-    isGroup() {
-        const ret = wasm.peer_isGroup(this.__wbg_ptr);
-        return ret !== 0;
+    get can() {
+        const ret = wasm.membership_can(this.__wbg_ptr);
+        return Access.__wrap(ret);
     }
     /**
-     * @returns {boolean}
+     * @returns {Agent}
      */
-    isDocument() {
-        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);
+    get who() {
+        const ret = wasm.membership_who(this.__wbg_ptr);
+        return Agent.__wrap(ret);
     }
 }
-if (Symbol.dispose) RemoveCiphertextError.prototype[Symbol.dispose] = RemoveCiphertextError.prototype.free;
-
-const RevocationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_revocation_free(ptr >>> 0, 1));
-
-export class Revocation {
+if (Symbol.dispose) Membership.prototype[Symbol.dispose] = Membership.prototype.free;
 
+export class Peer {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Revocation.prototype);
+        const obj = Object.create(Peer.prototype);
         obj.__wbg_ptr = ptr;
-        RevocationFinalization.register(obj, obj.__wbg_ptr, obj);
+        PeerFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        RevocationFinalization.unregister(this);
+        PeerFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_revocation_free(ptr, 0);
+        wasm.__wbg_peer_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`JsPeer`].
+     * @returns {Peer}
+     */
+    __wasm_refgen_toJsPeer() {
+        const ret = wasm.peer___wasm_refgen_toJsPeer(this.__wbg_ptr);
+        return Peer.__wrap(ret);
     }
     /**
      * @returns {Identifier}
      */
-    get subject_id() {
-        const ret = wasm.revocation_subject_id(this.__wbg_ptr);
+    get id() {
+        const ret = wasm.peer_id(this.__wbg_ptr);
         return Identifier.__wrap(ret);
     }
     /**
-     * @returns {SignedDelegation}
+     * @returns {boolean}
      */
-    get revoked() {
-        const ret = wasm.revocation_revoked(this.__wbg_ptr);
-        return SignedDelegation.__wrap(ret);
+    isDocument() {
+        const ret = wasm.peer_isDocument(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * @returns {SignedDelegation | undefined}
+     * @returns {boolean}
      */
-    get proof() {
-        const ret = wasm.revocation_proof(this.__wbg_ptr);
-        return ret === 0 ? undefined : SignedDelegation.__wrap(ret);
+    isGroup() {
+        const ret = wasm.peer_isGroup(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
-     * @returns {History}
+     * @returns {boolean}
      */
-    get after() {
-        const ret = wasm.revocation_after(this.__wbg_ptr);
-        return History.__wrap(ret);
-    }
-}
-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);
+    isIndividual() {
+        const ret = wasm.peer_isIndividual(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
      * @returns {string}
      */
-    get message() {
+    toString() {
         let deferred1_0;
         let deferred1_1;
         try {
-            const ret = wasm.revokemembererror_message(this.__wbg_ptr);
+            const ret = wasm.peer_toString(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -2442,93 +1936,89 @@ export class RevokeMemberError {
         }
     }
 }
-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 {
+if (Symbol.dispose) Peer.prototype[Symbol.dispose] = Peer.prototype.free;
 
+export class Revocation {
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(SerializationError.prototype);
+        const obj = Object.create(Revocation.prototype);
         obj.__wbg_ptr = ptr;
-        SerializationErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        RevocationFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SerializationErrorFinalization.unregister(this);
+        RevocationFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_serializationerror_free(ptr, 0);
+        wasm.__wbg_revocation_free(ptr, 0);
     }
     /**
-     * @returns {any}
+     * @returns {History}
      */
-    toError() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.serializationerror_toError(ptr);
-        return ret;
+    get after() {
+        const ret = wasm.revocation_after(this.__wbg_ptr);
+        return History.__wrap(ret);
+    }
+    /**
+     * @returns {SignedDelegation | undefined}
+     */
+    get proof() {
+        const ret = wasm.revocation_proof(this.__wbg_ptr);
+        return ret === 0 ? undefined : SignedDelegation.__wrap(ret);
+    }
+    /**
+     * @returns {SignedDelegation}
+     */
+    get revoked() {
+        const ret = wasm.revocation_revoked(this.__wbg_ptr);
+        return SignedDelegation.__wrap(ret);
+    }
+    /**
+     * @returns {Identifier}
+     */
+    get subject_id() {
+        const ret = wasm.revocation_subject_id(this.__wbg_ptr);
+        return Identifier.__wrap(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));
+if (Symbol.dispose) Revocation.prototype[Symbol.dispose] = Revocation.prototype.free;
 
 export class ShareKey {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(ShareKey.prototype);
         obj.__wbg_ptr = ptr;
         ShareKeyFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         ShareKeyFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_sharekey_free(ptr, 0);
     }
-}
-if (Symbol.dispose) ShareKey.prototype[Symbol.dispose] = ShareKey.prototype.free;
-
-const SignedFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signed_free(ptr >>> 0, 1));
+}
+if (Symbol.dispose) ShareKey.prototype[Symbol.dispose] = ShareKey.prototype.free;
 
 export class Signed {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Signed.prototype);
         obj.__wbg_ptr = ptr;
         SignedFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SignedFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signed_free(ptr, 0);
@@ -2541,29 +2031,25 @@ 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);
+    get payload() {
+        const ret = wasm.signed_payload(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
-    /**
-     * @returns {boolean}
-     */
-    verify() {
-        const ret = wasm.signed_verify(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @returns {Uint8Array}
      */
-    get payload() {
-        const ret = wasm.signed_payload(this.__wbg_ptr);
+    get signature() {
+        const ret = wasm.signed_signature(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -2571,17 +2057,27 @@ export class Signed {
     /**
      * @returns {Uint8Array}
      */
-    get verifyingKey() {
-        const ret = wasm.signed_verifyingKey(this.__wbg_ptr);
+    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;
     }
+    /**
+     * @returns {boolean}
+     */
+    verify() {
+        const ret = wasm.signed_verify(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {Uint8Array}
      */
-    get signature() {
-        const ret = wasm.signed_signature(this.__wbg_ptr);
+    get verifyingKey() {
+        const ret = wasm.signed_verifyingKey(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -2589,38 +2085,23 @@ export class Signed {
 }
 if (Symbol.dispose) Signed.prototype[Symbol.dispose] = Signed.prototype.free;
 
-const SignedCgkaOperationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signedcgkaoperation_free(ptr >>> 0, 1));
-
 export class SignedCgkaOperation {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(SignedCgkaOperation.prototype);
         obj.__wbg_ptr = ptr;
         SignedCgkaOperationFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SignedCgkaOperationFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signedcgkaoperation_free(ptr, 0);
     }
-    /**
-     * @returns {boolean}
-     */
-    verify() {
-        const ret = wasm.signedcgkaoperation_verify(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @returns {CgkaOperation}
      */
@@ -2631,17 +2112,24 @@ export class SignedCgkaOperation {
     /**
      * @returns {Uint8Array}
      */
-    get verifyingKey() {
-        const ret = wasm.signedcgkaoperation_verifyingKey(this.__wbg_ptr);
+    get signature() {
+        const ret = wasm.signedcgkaoperation_signature(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @returns {boolean}
+     */
+    verify() {
+        const ret = wasm.signedcgkaoperation_verify(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {Uint8Array}
      */
-    get signature() {
-        const ret = wasm.signedcgkaoperation_signature(this.__wbg_ptr);
+    get verifyingKey() {
+        const ret = wasm.signedcgkaoperation_verifyingKey(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -2649,38 +2137,23 @@ export class SignedCgkaOperation {
 }
 if (Symbol.dispose) SignedCgkaOperation.prototype[Symbol.dispose] = SignedCgkaOperation.prototype.free;
 
-const SignedDelegationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signeddelegation_free(ptr >>> 0, 1));
-
 export class SignedDelegation {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(SignedDelegation.prototype);
         obj.__wbg_ptr = ptr;
         SignedDelegationFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SignedDelegationFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signeddelegation_free(ptr, 0);
     }
-    /**
-     * @returns {boolean}
-     */
-    verify() {
-        const ret = wasm.signeddelegation_verify(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @returns {Delegation}
      */
@@ -2691,17 +2164,31 @@ export class SignedDelegation {
     /**
      * @returns {Uint8Array}
      */
-    get verifyingKey() {
-        const ret = wasm.signeddelegation_verifyingKey(this.__wbg_ptr);
+    get signature() {
+        const ret = wasm.signeddelegation_signature(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @returns {Identifier}
+     */
+    get subjectId() {
+        const ret = wasm.signeddelegation_subjectId(this.__wbg_ptr);
+        return Identifier.__wrap(ret);
+    }
+    /**
+     * @returns {boolean}
+     */
+    verify() {
+        const ret = wasm.signeddelegation_verify(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {Uint8Array}
      */
-    get signature() {
-        const ret = wasm.signeddelegation_signature(this.__wbg_ptr);
+    get verifyingKey() {
+        const ret = wasm.signeddelegation_verifyingKey(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -2709,19 +2196,13 @@ export class SignedDelegation {
 }
 if (Symbol.dispose) SignedDelegation.prototype[Symbol.dispose] = SignedDelegation.prototype.free;
 
-const SignedInvocationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signedinvocation_free(ptr >>> 0, 1));
-
 export class SignedInvocation {
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SignedInvocationFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signedinvocation_free(ptr, 0);
@@ -2729,38 +2210,23 @@ export class SignedInvocation {
 }
 if (Symbol.dispose) SignedInvocation.prototype[Symbol.dispose] = SignedInvocation.prototype.free;
 
-const SignedRevocationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signedrevocation_free(ptr >>> 0, 1));
-
 export class SignedRevocation {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(SignedRevocation.prototype);
         obj.__wbg_ptr = ptr;
         SignedRevocationFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SignedRevocationFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signedrevocation_free(ptr, 0);
     }
-    /**
-     * @returns {boolean}
-     */
-    verify() {
-        const ret = wasm.signedrevocation_verify(this.__wbg_ptr);
-        return ret !== 0;
-    }
     /**
      * @returns {Revocation}
      */
@@ -2771,17 +2237,24 @@ export class SignedRevocation {
     /**
      * @returns {Uint8Array}
      */
-    get verifyingKey() {
-        const ret = wasm.signedrevocation_verifyingKey(this.__wbg_ptr);
+    get signature() {
+        const ret = wasm.signedrevocation_signature(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @returns {boolean}
+     */
+    verify() {
+        const ret = wasm.signedrevocation_verify(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {Uint8Array}
      */
-    get signature() {
-        const ret = wasm.signedrevocation_signature(this.__wbg_ptr);
+    get verifyingKey() {
+        const ret = wasm.signedrevocation_verifyingKey(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
@@ -2789,31 +2262,30 @@ export class SignedRevocation {
 }
 if (Symbol.dispose) SignedRevocation.prototype[Symbol.dispose] = SignedRevocation.prototype.free;
 
-const SignerFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signer_free(ptr >>> 0, 1));
-
 export class Signer {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Signer.prototype);
         obj.__wbg_ptr = ptr;
         SignerFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SignerFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_signer_free(ptr, 0);
     }
+    /**
+     * @returns {Signer}
+     */
+    clone() {
+        const ret = wasm.signer_clone(this.__wbg_ptr);
+        return Signer.__wrap(ret);
+    }
     /**
      * @returns {Promise<Signer>}
      */
@@ -2849,11 +2321,13 @@ export class Signer {
         return Signer.__wrap(ret[0]);
     }
     /**
-     * @param {any} keypair
-     * @returns {Promise<Signer>}
+     * @param {Uint8Array} bytes
+     * @returns {Promise<Signed>}
      */
-    static webCryptoSigner(keypair) {
-        const ret = wasm.signer_webCryptoSigner(keypair);
+    trySign(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signer_trySign(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
@@ -2871,16 +2345,6 @@ export class Signer {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * @param {Uint8Array} bytes
-     * @returns {Promise<Signed>}
-     */
-    trySign(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.signer_trySign(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
     /**
      * @returns {Uint8Array}
      */
@@ -2891,132 +2355,200 @@ export class Signer {
         return v1;
     }
     /**
-     * @returns {Signer}
+     * @param {any} keypair
+     * @returns {Promise<Signer>}
      */
-    clone() {
-        const ret = wasm.signer_clone(this.__wbg_ptr);
-        return Signer.__wrap(ret);
+    static webCryptoSigner(keypair) {
+        const ret = wasm.signer_webCryptoSigner(keypair);
+        return ret;
     }
 }
 if (Symbol.dispose) Signer.prototype[Symbol.dispose] = Signer.prototype.free;
 
-const SigningErrorFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signingerror_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);
-        }
+    get activePrekeyCount() {
+        const ret = wasm.stats_activePrekeyCount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
-}
-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;
+    /**
+     * @returns {bigint}
+     */
+    get cgkaOperations() {
+        const ret = wasm.stats_cgkaOperations(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 delegations() {
+        const ret = wasm.stats_delegations(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 {bigint}
+     */
+    get groups() {
+        const ret = wasm.stats_groups(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get individuals() {
+        const ret = wasm.stats_individuals(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingCgkaOperation() {
+        const ret = wasm.stats_pendingCgkaOperation(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingCgkaOperationByActive() {
+        const ret = wasm.stats_pendingCgkaOperationByActive(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingDelegated() {
+        const ret = wasm.stats_pendingDelegated(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingDelegatedByActive() {
+        const ret = wasm.stats_pendingDelegatedByActive(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingPrekeyRotated() {
+        const ret = wasm.stats_pendingPrekeyRotated(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingPrekeyRotatedByActive() {
+        const ret = wasm.stats_pendingPrekeyRotatedByActive(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingPrekeysExpanded() {
+        const ret = wasm.stats_pendingPrekeysExpanded(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingPrekeysExpandedByActive() {
+        const ret = wasm.stats_pendingPrekeysExpandedByActive(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingRevoked() {
+        const ret = wasm.stats_pendingRevoked(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get pendingRevokedByActive() {
+        const ret = wasm.stats_pendingRevokedByActive(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get prekeyRotations() {
+        const ret = wasm.stats_prekeyRotations(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get prekeysExpanded() {
+        const ret = wasm.stats_prekeysExpanded(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 revocations() {
+        const ret = wasm.stats_revocations(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 totalOps() {
+        const ret = wasm.stats_totalOps(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get totalPendingOps() {
+        const ret = wasm.stats_totalPendingOps(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
     }
 }
-if (Symbol.dispose) SimpleCapability.prototype[Symbol.dispose] = SimpleCapability.prototype.free;
-
-const SummaryFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_summary_free(ptr >>> 0, 1));
+if (Symbol.dispose) Stats.prototype[Symbol.dispose] = Stats.prototype.free;
 
 export class Summary {
-
     static __wrap(ptr) {
-        ptr = ptr >>> 0;
         const obj = Object.create(Summary.prototype);
         obj.__wbg_ptr = ptr;
         SummaryFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
-
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
         SummaryFinalization.unregister(this);
         return ptr;
     }
-
     free() {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_summary_free(ptr, 0);
     }
-    /**
-     * @returns {Document}
-     */
-    get doc() {
-        const ret = wasm.summary_doc(this.__wbg_ptr);
-        return Document.__wrap(ret);
-    }
     /**
      * @returns {Access}
      */
@@ -3024,121 +2556,168 @@ export class Summary {
         const ret = wasm.summary_access(this.__wbg_ptr);
         return Access.__wrap(ret);
     }
-}
-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}
+     * @returns {Document}
      */
-    toError() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.tryfromarchiveerror_toError(ptr);
-        return ret;
+    get doc() {
+        const ret = wasm.summary_doc(this.__wbg_ptr);
+        return Document.__wrap(ret);
     }
 }
-if (Symbol.dispose) TryFromArchiveError.prototype[Symbol.dispose] = TryFromArchiveError.prototype.free;
+if (Symbol.dispose) Summary.prototype[Symbol.dispose] = Summary.prototype.free;
 
-export function __wbg_Error_e17e777aac105295(arg0, arg1) {
+/**
+ * Panic hook lets us get better error messages if our Rust code ever panics.
+ *
+ * This function needs to be called at least once during initialisation.
+ * https://rustwasm.github.io/docs/wasm-pack/tutorials/npm-browser-packages/template-deep-dive/src-utils-rs.html#2-what-is-console_error_panic_hook
+ */
+export function setPanicHook() {
+    wasm.setPanicHook();
+}
+export function __wbg_Error_fdd633d4bb5dd76a(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return ret;
-};
-
-export function __wbg_addmembererror_new(arg0) {
-    const ret = AddMemberError.__wrap(arg0);
+}
+export function __wbg___wasm_refgen_toJsChangeId_1a4e8d260f698820(arg0) {
+    const ret = arg0.__wasm_refgen_toJsChangeId();
+    _assertClass(ret, ChangeId);
+    var ptr1 = ret.__destroy_into_raw();
+    return ptr1;
+}
+export function __wbg___wasm_refgen_toJsDocument_bb9bc0924846047d(arg0) {
+    const ret = arg0.__wasm_refgen_toJsDocument();
+    _assertClass(ret, Document);
+    var ptr1 = ret.__destroy_into_raw();
+    return ptr1;
+}
+export function __wbg___wasm_refgen_toJsPeer_17636bceb3369eeb(arg0) {
+    const ret = arg0.__wasm_refgen_toJsPeer();
+    _assertClass(ret, Peer);
+    var ptr1 = ret.__destroy_into_raw();
+    return ptr1;
+}
+export function __wbg___wbindgen_debug_string_8a447059637473e2(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);
+}
+export function __wbg___wbindgen_is_function_acc5528be2b923f2(arg0) {
+    const ret = typeof(arg0) === 'function';
     return ret;
-};
-
-export function __wbg_call_13410aac570ffff7() { return handleError(function (arg0, arg1) {
-    const ret = arg0.call(arg1);
+}
+export function __wbg___wbindgen_is_object_0beba4a1980d3eea(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
     return ret;
-}, arguments) };
-
-export function __wbg_call_a5400b25a865cfd8() { return handleError(function (arg0, arg1, arg2) {
+}
+export function __wbg___wbindgen_is_string_1fca8072260dd261(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_721f8decd50c87a3(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_throw_ea4887a5f8f9a9db(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg__wbg_cb_unref_33c39e13d73b25f6(arg0) {
+    arg0._wbg_cb_unref();
+}
+export function __wbg_access_new(arg0) {
+    const ret = Access.__wrap(arg0);
+    return ret;
+}
+export function __wbg_add_8db1450e4b353bba(arg0, arg1) {
+    const ret = arg0.add(arg1);
+    return ret;
+}
+export function __wbg_addmemberupdate_new(arg0) {
+    const ret = AddMemberUpdate.__wrap(arg0);
+    return ret;
+}
+export function __wbg_agent_new(arg0) {
+    const ret = Agent.__wrap(arg0);
+    return ret;
+}
+export function __wbg_allagentevents_new(arg0) {
+    const ret = AllAgentEvents.__wrap(arg0);
+    return ret;
+}
+export function __wbg_archive_new(arg0) {
+    const ret = Archive.__wrap(arg0);
+    return ret;
+}
+export function __wbg_call_5575218572ead796() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.call(arg1, arg2);
     return ret;
-}, arguments) };
-
+}, arguments); }
 export function __wbg_cannotparseed25519signingkey_new(arg0) {
     const ret = CannotParseEd25519SigningKey.__wrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_cannotparseidentifier_new(arg0) {
     const ret = CannotParseIdentifier.__wrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_capability_new(arg0) {
     const ret = Capability.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_changeref_new(arg0) {
-    const ret = ChangeRef.__wrap(arg0);
+}
+export function __wbg_changeid_new(arg0) {
+    const ret = ChangeId.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_changeref_unwrap(arg0) {
-    const ret = ChangeRef.__unwrap(arg0);
+}
+export function __wbg_changeid_unwrap(arg0) {
+    const ret = ChangeId.__unwrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_contactcard_new(arg0) {
     const ret = ContactCard.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_crypto_574e78ad8b13b65f(arg0) {
+}
+export function __wbg_crypto_38df2bab126b63dc(arg0) {
     const ret = arg0.crypto;
     return ret;
-};
-
+}
+export function __wbg_debug_1995429f18ef72ac(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);
+    }
+}
+export function __wbg_debug_3003e89da631cad7(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);
+    }
+}
 export function __wbg_doccontentrefs_new(arg0) {
     const ret = DocContentRefs.__wrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_document_new(arg0) {
     const ret = Document.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_document_unwrap(arg0) {
-    const ret = Document.__unwrap(arg0);
-    return ret;
-};
-
+}
 export function __wbg_encryptedcontentwithupdate_new(arg0) {
     const ret = EncryptedContentWithUpdate.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
+}
+export function __wbg_error_8b62d3db440cf4a8(arg0, arg1) {
     let deferred0_0;
     let deferred0_1;
     try {
@@ -3148,58 +2727,73 @@ export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
     } finally {
         wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
     }
-};
-
+}
+export function __wbg_error_a6fa202b58aa1cd3(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);
+    }
+}
+export function __wbg_error_c90492381694a8af(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);
+    }
+}
 export function __wbg_event_new(arg0) {
     const ret = Event.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_exportKey_4a1163511775473d() { return handleError(function (arg0, arg1, arg2, arg3) {
+}
+export function __wbg_exportKey_1ce2ce04d90beed3() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = arg0.exportKey(getStringFromWasm0(arg1, arg2), arg3);
     return ret;
-}, arguments) };
-
-export function __wbg_generateKey_b8902ccb0e50ff4e() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+}, arguments); }
+export function __wbg_generateKey_d7565f8a873b2758() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     const ret = arg0.generateKey(getStringFromWasm0(arg1, arg2), arg3 !== 0, arg4);
     return ret;
-}, arguments) };
-
-export function __wbg_generatedocerror_new(arg0) {
-    const ret = GenerateDocError.__wrap(arg0);
-    return ret;
-};
-
+}, arguments); }
 export function __wbg_generatewebcryptoerror_new(arg0) {
     const ret = GenerateWebCryptoError.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_getRandomValues_b8f5dbd5f3995a9e() { return handleError(function (arg0, arg1) {
+}
+export function __wbg_getRandomValues_c44a50d8cfdaebeb() { return handleError(function (arg0, arg1) {
     arg0.getRandomValues(arg1);
-}, arguments) };
-
-export function __wbg_get_458e874b43b18b25() { return handleError(function (arg0, arg1) {
+}, arguments); }
+export function __wbg_get_197a3fe98f169e38(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_get_dddb90ff5d27a080() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(arg0, arg1);
     return ret;
-}, arguments) };
-
-export function __wbg_getprivatekey_2b060a8a8c19d828(arg0) {
+}, arguments); }
+export function __wbg_get_private_key_5512a2630ab9366a(arg0) {
     const ret = arg0.privateKey;
     return ret;
-};
-
-export function __wbg_getpublickey_ad4c2474164b2d9a(arg0) {
+}
+export function __wbg_get_public_key_bd0de162bf5c6832(arg0) {
     const ret = arg0.publicKey;
     return ret;
-};
-
+}
 export function __wbg_group_new(arg0) {
     const ret = Group.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_instanceof_Crypto_33ac2d91cca59233(arg0) {
+}
+export function __wbg_individual_new(arg0) {
+    const ret = Individual.__wrap(arg0);
+    return ret;
+}
+export function __wbg_instanceof_Crypto_cecf3f85e92e02f6(arg0) {
     let result;
     try {
         result = arg0 instanceof Crypto;
@@ -3208,322 +2802,719 @@ export function __wbg_instanceof_Crypto_33ac2d91cca59233(arg0) {
     }
     const ret = result;
     return ret;
-};
-
-export function __wbg_jsdecrypterror_new(arg0) {
-    const ret = JsDecryptError.__wrap(arg0);
-    return ret;
-};
-
-export function __wbg_jsencrypterror_new(arg0) {
-    const ret = JsEncryptError.__wrap(arg0);
-    return ret;
-};
-
-export function __wbg_jsreceiveprekeyoperror_new(arg0) {
-    const ret = JsReceivePreKeyOpError.__wrap(arg0);
-    return ret;
-};
-
-export function __wbg_jsreceivestaticeventerror_new(arg0) {
-    const ret = JsReceiveStaticEventError.__wrap(arg0);
-    return ret;
-};
-
+}
 export function __wbg_keyhive_new(arg0) {
     const ret = Keyhive.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_length_6bb7e81f9d7713e4(arg0) {
+}
+export function __wbg_length_589238bdcf171f0e(arg0) {
     const ret = arg0.length;
     return ret;
-};
-
-export function __wbg_msCrypto_a61aeb35a24c1329(arg0) {
+}
+export function __wbg_length_c6054974c0a6cdb9(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_log_17a3e9a5cbb91ef7(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);
+    }
+}
+export function __wbg_log_e885b89e7e480a2f(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);
+    }
+}
+export function __wbg_mark_0279c5d75168b5b8(arg0, arg1) {
+    performance.mark(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_measure_c9b58ac538b3e2f7() { 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); }
+export function __wbg_membership_new(arg0) {
+    const ret = Membership.__wrap(arg0);
+    return ret;
+}
+export function __wbg_msCrypto_bd5a034af96bcba6(arg0) {
     const ret = arg0.msCrypto;
     return ret;
-};
-
-export function __wbg_new_2e3c58a15f39f5f9(arg0, arg1) {
+}
+export function __wbg_new_227d7c05414eb861() {
+    const ret = new Error();
+    return ret;
+}
+export function __wbg_new_3444eb7412549f0b() {
+    const ret = new Map();
+    return ret;
+}
+export function __wbg_new_36e147a8ced3c6e0() {
+    const ret = new Array();
+    return ret;
+}
+export function __wbg_new_4a05b166716eeed6(arg0) {
+    const ret = new Set(arg0);
+    return ret;
+}
+export function __wbg_new_81880fb5002cb255(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+}
+export function __wbg_new_e66a4b7758dd2e5c(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_from_slice_543b875b27789a8f(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_typed_00a409eb4ec4f2d9(arg0, arg1) {
     try {
         var state0 = {a: arg0, b: arg1};
         var cb0 = (arg0, arg1) => {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_273(a, state0.b, arg0, arg1);
+                return wasm_bindgen__convert__closures_____invoke__h1ce7fe53f08aa9a8(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
         };
         const ret = new Promise(cb0);
         return ret;
-    } finally {
-        state0.a = state0.b = 0;
-    }
-};
-
-export function __wbg_new_638ebfaedbf32a5e(arg0) {
-    const ret = new Uint8Array(arg0);
-    return ret;
-};
-
-export function __wbg_new_8a6f238a6ece86ea() {
-    const ret = new Error();
-    return ret;
-};
-
-export function __wbg_newnoargs_254190557c45b4ec(arg0, arg1) {
-    const ret = new Function(getStringFromWasm0(arg0, arg1));
-    return ret;
-};
-
-export function __wbg_newwithlength_a167dcc7aaa3ba77(arg0) {
+    } finally {
+        state0.a = 0;
+    }
+}
+export function __wbg_new_with_length_9b650f44b5c44a4e(arg0) {
     const ret = new Uint8Array(arg0 >>> 0);
     return ret;
-};
-
-export function __wbg_node_905d3e251edff8a2(arg0) {
+}
+export function __wbg_node_84ea875411254db1(arg0) {
     const ret = arg0.node;
     return ret;
-};
-
-export function __wbg_peer_unwrap(arg0) {
-    const ret = Peer.__unwrap(arg0);
-    return ret;
-};
-
-export function __wbg_process_dc0fbacc7c1c06f7(arg0) {
+}
+export function __wbg_process_44c7a14e11e9f69e(arg0) {
     const ret = arg0.process;
     return ret;
-};
-
-export function __wbg_prototypesetcall_3d4a26c1ed734349(arg0, arg1, arg2) {
+}
+export function __wbg_prototypesetcall_d721637c7ca66eb8(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
-};
-
-export function __wbg_queueMicrotask_25d0739ac89e8c88(arg0) {
-    queueMicrotask(arg0);
-};
-
-export function __wbg_queueMicrotask_4488407636f5bf24(arg0) {
+}
+export function __wbg_push_f724b5db8acf89d2(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+}
+export function __wbg_queueMicrotask_1c9b3800e321a967(arg0) {
     const ret = arg0.queueMicrotask;
     return ret;
-};
-
-export function __wbg_randomFillSync_ac0988aba3254290() { return handleError(function (arg0, arg1) {
+}
+export function __wbg_queueMicrotask_311744e534a929a3(arg0) {
+    queueMicrotask(arg0);
+}
+export function __wbg_randomFillSync_6c25eac9869eb53c() { return handleError(function (arg0, arg1) {
     arg0.randomFillSync(arg1);
-}, arguments) };
-
-export function __wbg_require_60cc747a6bc5215a() { return handleError(function () {
+}, arguments); }
+export function __wbg_require_b4edbdcf3e2a1ef0() { return handleError(function () {
     const ret = module.require;
     return ret;
-}, arguments) };
-
-export function __wbg_resolve_4055c623acdd6a1b(arg0) {
+}, arguments); }
+export function __wbg_resolve_d82363d90af6928a(arg0) {
     const ret = Promise.resolve(arg0);
     return ret;
-};
-
-export function __wbg_revokemembererror_new(arg0) {
-    const ret = RevokeMemberError.__wrap(arg0);
-    return ret;
-};
-
-export function __wbg_serializationerror_new(arg0) {
-    const ret = SerializationError.__wrap(arg0);
+}
+export function __wbg_set_9a1d61e17de7054c(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
     return ret;
-};
-
+}
+export function __wbg_set_name_15bb90053efbc017(arg0, arg1, arg2) {
+    arg0.name = getStringFromWasm0(arg1, arg2);
+}
 export function __wbg_sharekey_new(arg0) {
     const ret = ShareKey.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_sign_8891059f121b31b5() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+}
+export function __wbg_sign_12a498c8600b5618() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     const ret = arg0.sign(arg1, arg2, getArrayU8FromWasm0(arg3, arg4));
     return ret;
-}, arguments) };
-
+}, arguments); }
 export function __wbg_signed_new(arg0) {
     const ret = Signed.__wrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_signeddelegation_new(arg0) {
     const ret = SignedDelegation.__wrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_signedrevocation_new(arg0) {
     const ret = SignedRevocation.__wrap(arg0);
     return ret;
-};
-
+}
 export function __wbg_signer_new(arg0) {
     const ret = Signer.__wrap(arg0);
     return ret;
-};
-
-export function __wbg_signingerror_new(arg0) {
-    const ret = SigningError.__wrap(arg0);
-    return ret;
-};
-
-export function __wbg_simplecapability_new(arg0) {
-    const ret = SimpleCapability.__wrap(arg0);
-    return ret;
-};
-
-export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
+}
+export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     const ret = arg1.stack;
     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);
-};
+}
+export function __wbg_static_accessor_GLOBAL_THIS_2fee5048bcca5938() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_GLOBAL_ce44e66a4935da8c() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_SELF_44f6e0cb5e67cdad() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_WINDOW_168f178805d978fe() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_stats_new(arg0) {
+    const ret = Stats.__wrap(arg0);
+    return ret;
+}
+export function __wbg_subarray_b0e8ac4ed313fea8(arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+    return ret;
+}
+export function __wbg_subtle_1287656b3b345d44(arg0) {
+    const ret = arg0.subtle;
+    return ret;
+}
+export function __wbg_summary_new(arg0) {
+    const ret = Summary.__wrap(arg0);
+    return ret;
+}
+export function __wbg_then_05edfc8a4fea5106(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+}
+export function __wbg_then_591b6b3a75ee817a(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+}
+export function __wbg_versions_276b2795b1c6a219(arg0) {
+    const ret = arg0.versions;
+    return ret;
+}
+export function __wbg_warn_2a49b47d25e1e018(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);
+    }
+}
+export function __wbg_warn_9d7408e9659996aa(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);
+    }
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 711, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hd575a1431d676418);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000003(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000004(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("Capability")) -> Externref`.
+    const ret = v0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000005(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;
+}
+export function __wbindgen_cast_0000000000000006(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;
+}
+export function __wbindgen_cast_0000000000000007(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("SignedRevocation")) -> Externref`.
+    const ret = v0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000008(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;
+}
+export function __wbindgen_cast_0000000000000009(arg0, arg1) {
+    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
+    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
+    // Cast intrinsic for `Vector(NamedExternref("Uint8Array")) -> Externref`.
+    const ret = v0;
+    return ret;
+}
+export function __wbindgen_cast_000000000000000a(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;
+}
+export function __wbindgen_cast_000000000000000b(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;
+}
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+}
+function wasm_bindgen__convert__closures_____invoke__hd575a1431d676418(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__hd575a1431d676418(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen__convert__closures_____invoke__h1ce7fe53f08aa9a8(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h1ce7fe53f08aa9a8(arg0, arg1, arg2, arg3);
+}
+
+const AccessFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_access_free(ptr, 1));
+const AddMemberUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_addmemberupdate_free(ptr, 1));
+const AgentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_agent_free(ptr, 1));
+const AllAgentEventsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_allagentevents_free(ptr, 1));
+const ArchiveFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_archive_free(ptr, 1));
+const CannotParseEd25519SigningKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cannotparseed25519signingkey_free(ptr, 1));
+const CannotParseIdentifierFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cannotparseidentifier_free(ptr, 1));
+const CapabilityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_capability_free(ptr, 1));
+const CgkaOperationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_cgkaoperation_free(ptr, 1));
+const ChangeIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_changeid_free(ptr, 1));
+const CiphertextStoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ciphertextstore_free(ptr, 1));
+const ContactCardFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_contactcard_free(ptr, 1));
+const DelegationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_delegation_free(ptr, 1));
+const DocContentRefsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_doccontentrefs_free(ptr, 1));
+const DocumentFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_document_free(ptr, 1));
+const DocumentIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_documentid_free(ptr, 1));
+const EncryptedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encrypted_free(ptr, 1));
+const EncryptedContentWithUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_encryptedcontentwithupdate_free(ptr, 1));
+const EventFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_event_free(ptr, 1));
+const GenerateWebCryptoErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_generatewebcryptoerror_free(ptr, 1));
+const GroupFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_group_free(ptr, 1));
+const GroupIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_groupid_free(ptr, 1));
+const HistoryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_history_free(ptr, 1));
+const IdentifierFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identifier_free(ptr, 1));
+const IndividualFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_individual_free(ptr, 1));
+const IndividualIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_individualid_free(ptr, 1));
+const InvocationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_invocation_free(ptr, 1));
+const KeyhiveFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_keyhive_free(ptr, 1));
+const MemberedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_membered_free(ptr, 1));
+const MembershipFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_membership_free(ptr, 1));
+const PeerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_peer_free(ptr, 1));
+const RevocationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_revocation_free(ptr, 1));
+const ShareKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sharekey_free(ptr, 1));
+const SignedFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signed_free(ptr, 1));
+const SignedCgkaOperationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signedcgkaoperation_free(ptr, 1));
+const SignedDelegationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signeddelegation_free(ptr, 1));
+const SignedInvocationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signedinvocation_free(ptr, 1));
+const SignedRevocationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signedrevocation_free(ptr, 1));
+const SignerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_signer_free(ptr, 1));
+const StatsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_stats_free(ptr, 1));
+const SummaryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_summary_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
+
+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;
+}
 
-export function __wbg_static_accessor_GLOBAL_8921f820c2ce3f12() {
-    const ret = typeof global === 'undefined' ? null : global;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-};
+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)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
 
-export function __wbg_static_accessor_GLOBAL_THIS_f0a4409105898184() {
-    const ret = typeof globalThis === 'undefined' ? null : globalThis;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-};
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
 
-export function __wbg_static_accessor_SELF_995b214ae681ff99() {
-    const ret = typeof self === 'undefined' ? null : self;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-};
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
 
-export function __wbg_static_accessor_WINDOW_cde3890479c675ea() {
-    const ret = typeof window === 'undefined' ? null : window;
-    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-};
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
 
-export function __wbg_subarray_70fd07feefe14294(arg0, arg1, arg2) {
-    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
-    return ret;
-};
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
 
-export function __wbg_subtle_dd66747d3e9a93d4(arg0) {
-    const ret = arg0.subtle;
-    return ret;
-};
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
 
-export function __wbg_summary_new(arg0) {
-    const ret = Summary.__wrap(arg0);
-    return ret;
-};
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
 
-export function __wbg_then_b33a773d723afa3e(arg0, arg1, arg2) {
-    const ret = arg0.then(arg1, arg2);
-    return ret;
-};
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
 
-export function __wbg_then_e22500defe16819f(arg0, arg1) {
-    const ret = arg0.then(arg1);
-    return ret;
-};
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_destroy_closure(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
 
-export function __wbg_tryfromarchiveerror_new(arg0) {
-    const ret = TryFromArchiveError.__wrap(arg0);
-    return ret;
-};
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 
-export function __wbg_versions_c01dfd4722a88165(arg0) {
-    const ret = arg0.versions;
-    return ret;
-};
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
 
-export function __wbg_wbindgencbdrop_eb10308566512b88(arg0) {
-    const obj = arg0.original;
-    if (obj.cnt-- == 1) {
-        obj.a = 0;
-        return true;
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
     }
-    const ret = false;
-    return ret;
-};
 
-export function __wbg_wbindgendebugstring_99ef257a3ddda34d(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);
-};
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
 
-export function __wbg_wbindgenisfunction_8cee7dce3725ae74(arg0) {
-    const ret = typeof(arg0) === 'function';
-    return ret;
-};
+    const mem = getUint8ArrayMemory0();
 
-export function __wbg_wbindgenisobject_307a53c6bd97fbf8(arg0) {
-    const val = arg0;
-    const ret = typeof(val) === 'object' && val !== null;
-    return ret;
-};
+    let offset = 0;
 
-export function __wbg_wbindgenisstring_d4fa939789f003b0(arg0) {
-    const ret = typeof(arg0) === 'string';
-    return ret;
-};
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
 
-export function __wbg_wbindgenisundefined_c4b71d073b92f3c5(arg0) {
-    const ret = arg0 === undefined;
-    return ret;
-};
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
 
-export function __wbg_wbindgenthrow_451ec1a8469d7eb6(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-};
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
 
-export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
-    // Cast intrinsic for `Ref(String) -> Externref`.
-    const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
-};
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
 
-export function __wbindgen_cast_25a0a844437d0e92(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;
-};
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
 
-export function __wbindgen_cast_878a9170ed4959ff(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 432, function: Function { arguments: [Externref], shim_idx: 433, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 432, __wbg_adapter_12);
-    return ret;
-};
+const cachedTextEncoder = new TextEncoder();
 
-export function __wbindgen_cast_ae91babfc5c19b28(arg0, arg1) {
-    var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
-    wasm.__wbindgen_free(arg0, arg1 * 4, 4);
-    // Cast intrinsic for `Vector(NamedExternref("SignedRevocation")) -> Externref`.
-    const ret = v0;
-    return ret;
-};
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
 
-export function __wbindgen_cast_cb9088102bce6b30(arg0, arg1) {
-    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-    const ret = getArrayU8FromWasm0(arg0, arg1);
-    return ret;
-};
+let WASM_VECTOR_LEN = 0;
 
-export function __wbindgen_init_externref_table() {
-    const table = wasm.__wbindgen_export_2;
-    const offset = table.grow(4);
-    table.set(0, undefined);
-    table.set(offset + 0, undefined);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
-    ;
-};
 
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}