@wireapp/core-crypto 7.0.2 → 8.0.1

package/src/corecrypto.js

@@ -22,17 +22,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/Ciphersuite.ts
-var Ciphersuite;
-((Ciphersuite2) => {
-  Ciphersuite2[Ciphersuite2["MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519"] = 1] = "MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519";
-  Ciphersuite2[Ciphersuite2["MLS_128_DHKEMP256_AES128GCM_SHA256_P256"] = 2] = "MLS_128_DHKEMP256_AES128GCM_SHA256_P256";
-  Ciphersuite2[Ciphersuite2["MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519"] = 3] = "MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519";
-  Ciphersuite2[Ciphersuite2["MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448"] = 4] = "MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448";
-  Ciphersuite2[Ciphersuite2["MLS_256_DHKEMP521_AES256GCM_SHA512_P521"] = 5] = "MLS_256_DHKEMP521_AES256GCM_SHA512_P521";
-  Ciphersuite2[Ciphersuite2["MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448"] = 6] = "MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448";
-  Ciphersuite2[Ciphersuite2["MLS_256_DHKEMP384_AES256GCM_SHA384_P384"] = 7] = "MLS_256_DHKEMP384_AES256GCM_SHA384_P384";
-})(Ciphersuite ||= {});
 // src/CoreCryptoError.ts
 class CoreCryptoError extends Error {
   errorStack;
@@ -54,9 +43,8 @@ class CoreCryptoError extends Error {
       this.proteusErrorCode = null;
     }
   }
-  static fallback(msg, ...params) {
-    console.warn(`Cannot build CoreCryptoError, falling back to standard Error! ctx: ${msg}`);
-    return new Error(msg, ...params);
+  static fallback(message, ...params) {
+    return new CoreCryptoError({ message }, ...params);
   }
   static build(msg, ...params) {
     try {
@@ -87,7 +75,7 @@ class CoreCryptoError extends Error {
     return await mappedErrorPromise;
   }
 }
-// src/core-crypto-ffi.js
+// src/autogenerated/core-crypto-ffi.js
 var wasm;
 var WASM_VECTOR_LEN = 0;
 var cachedUint8ArrayMemory0 = null;
@@ -258,17 +246,17 @@ ${val.stack}`;
   }
   return className;
 }
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
 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 _assertClass(instance, klass) {
-  if (!(instance instanceof klass)) {
-    throw new Error(`expected instance of ${klass.name}`);
-  }
-}
 function getArrayJsValueFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   const mem = getDataViewMemory0();
@@ -284,18 +272,16 @@ function takeFromExternrefTable0(idx) {
   wasm.__externref_table_dealloc(idx);
   return value;
 }
-var cachedUint16ArrayMemory0 = null;
-function getUint16ArrayMemory0() {
-  if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
-    cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
+function ciphersuiteFromU16(discriminant) {
+  const ret = wasm.ciphersuiteFromU16(discriminant);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
   }
-  return cachedUint16ArrayMemory0;
+  return ret[0];
 }
-function passArray16ToWasm0(arg, malloc) {
-  const ptr = malloc(arg.length * 2, 2) >>> 0;
-  getUint16ArrayMemory0().set(arg, ptr / 2);
-  WASM_VECTOR_LEN = arg.length;
-  return ptr;
+function ciphersuiteDefault() {
+  const ret = wasm.ciphersuiteDefault();
+  return ret;
 }
 function passArrayJsValueToWasm0(array, malloc) {
   const ptr = malloc(array.length * 4, 4) >>> 0;
@@ -315,6 +301,14 @@ function migrateDatabaseKeyTypeToBytes(name, old_key, new_key) {
   const ret = wasm.migrateDatabaseKeyTypeToBytes(ptr0, len0, ptr1, len1, new_key.__wbg_ptr);
   return ret;
 }
+function updateDatabaseKey(name, old_key, new_key) {
+  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  _assertClass(old_key, DatabaseKey);
+  _assertClass(new_key, DatabaseKey);
+  const ret = wasm.updateDatabaseKey(ptr0, len0, old_key.__wbg_ptr, new_key.__wbg_ptr);
+  return ret;
+}
 function version() {
   let deferred1_0;
   let deferred1_1;
@@ -331,18 +325,34 @@ function build_metadata() {
   const ret = wasm.build_metadata();
   return BuildMetadata.__wrap(ret);
 }
-function __wbg_adapter_60(arg0, arg1, arg2) {
-  wasm.closure971_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_62(arg0, arg1, arg2) {
+  wasm.closure963_externref_shim(arg0, arg1, arg2);
 }
-function __wbg_adapter_63(arg0, arg1, arg2) {
-  wasm.closure2664_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_65(arg0, arg1, arg2) {
+  wasm.closure2637_externref_shim(arg0, arg1, arg2);
 }
-function __wbg_adapter_66(arg0, arg1, arg2) {
-  wasm.closure2864_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_68(arg0, arg1, arg2) {
+  wasm.closure2839_externref_shim(arg0, arg1, arg2);
 }
-function __wbg_adapter_555(arg0, arg1, arg2, arg3) {
-  wasm.closure2959_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_565(arg0, arg1, arg2, arg3) {
+  wasm.closure2945_externref_shim(arg0, arg1, arg2, arg3);
 }
+var Ciphersuite = Object.freeze({
+  MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519: 1,
+  "1": "MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519",
+  MLS_128_DHKEMP256_AES128GCM_SHA256_P256: 2,
+  "2": "MLS_128_DHKEMP256_AES128GCM_SHA256_P256",
+  MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519: 3,
+  "3": "MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519",
+  MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448: 4,
+  "4": "MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448",
+  MLS_256_DHKEMP521_AES256GCM_SHA512_P521: 5,
+  "5": "MLS_256_DHKEMP521_AES256GCM_SHA512_P521",
+  MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448: 6,
+  "6": "MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448",
+  MLS_256_DHKEMP384_AES256GCM_SHA384_P384: 7,
+  "7": "MLS_256_DHKEMP384_AES256GCM_SHA384_P384"
+});
 var CoreCryptoLogLevel = Object.freeze({
   Off: 1,
   "1": "Off",
@@ -529,41 +539,6 @@ class AcmeDirectory {
     }
   }
 }
-var ArrayOfByteArrayFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_arrayofbytearray_free(ptr >>> 0, 1));
-
-class ArrayOfByteArray {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(ArrayOfByteArray.prototype);
-    obj.__wbg_ptr = ptr;
-    ArrayOfByteArrayFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    ArrayOfByteArrayFinalization.unregister(this);
-    return ptr;
-  }
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_arrayofbytearray_free(ptr, 0);
-  }
-  constructor(aoba) {
-    const ptr0 = passArrayJsValueToWasm0(aoba, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.arrayofbytearray_new(ptr0, len0);
-    this.__wbg_ptr = ret >>> 0;
-    ArrayOfByteArrayFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
-  as_arrays() {
-    const ret = wasm.arrayofbytearray_as_arrays(this.__wbg_ptr);
-    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v1;
-  }
-}
 var BufferedDecryptedMessageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_buffereddecryptedmessage_free(ptr >>> 0, 1));
 
 class BufferedDecryptedMessage {
@@ -615,7 +590,12 @@ class BufferedDecryptedMessage {
   }
   get crlNewDistributionPoints() {
     const ret = wasm.__wbg_get_buffereddecryptedmessage_crlNewDistributionPoints(this.__wbg_ptr);
-    return NewCrlDistributionPoints.__wrap(ret);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    }
+    return v1;
   }
 }
 var BuildMetadataFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_buildmetadata_free(ptr >>> 0, 1));
@@ -691,65 +671,6 @@ class BuildMetadata {
     return getStringFromWasm0(ret[0], ret[1]);
   }
 }
-var CiphersuiteFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_ciphersuite_free(ptr >>> 0, 1));
-
-class Ciphersuite2 {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(Ciphersuite2.prototype);
-    obj.__wbg_ptr = ptr;
-    CiphersuiteFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    CiphersuiteFinalization.unregister(this);
-    return ptr;
-  }
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_ciphersuite_free(ptr, 0);
-  }
-  as_u16() {
-    const ret = wasm.ciphersuite_as_u16(this.__wbg_ptr);
-    return ret;
-  }
-  constructor(discriminant) {
-    const ret = wasm.ciphersuite_new(discriminant);
-    if (ret[2]) {
-      throw takeFromExternrefTable0(ret[1]);
-    }
-    this.__wbg_ptr = ret[0] >>> 0;
-    CiphersuiteFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
-}
-var CiphersuitesFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_ciphersuites_free(ptr >>> 0, 1));
-
-class Ciphersuites {
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    CiphersuitesFinalization.unregister(this);
-    return ptr;
-  }
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_ciphersuites_free(ptr, 0);
-  }
-  constructor(ids) {
-    const ptr0 = passArray16ToWasm0(ids, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.ciphersuites_from_u16s(ptr0, len0);
-    if (ret[2]) {
-      throw takeFromExternrefTable0(ret[1]);
-    }
-    this.__wbg_ptr = ret[0] >>> 0;
-    CiphersuitesFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
-}
 var ClientIdFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_clientid_free(ptr >>> 0, 1));
 
 class ClientId {
@@ -784,8 +705,8 @@ class ClientId {
     ClientIdFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
-  as_bytes() {
-    const ret = wasm.clientid_as_bytes(this.__wbg_ptr);
+  copyBytes() {
+    const ret = wasm.clientid_copyBytes(this.__wbg_ptr);
     var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v1;
@@ -813,17 +734,15 @@ class CommitBundle {
   }
   get welcome() {
     const ret = wasm.__wbg_get_commitbundle_welcome(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;
+    return ret === 0 ? undefined : Welcome.__wrap(ret);
   }
   set welcome(arg0) {
-    var ptr0 = isLikeNone(arg0) ? 0 : passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
-    var len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_commitbundle_welcome(this.__wbg_ptr, ptr0, len0);
+    let ptr0 = 0;
+    if (!isLikeNone(arg0)) {
+      _assertClass(arg0, Welcome);
+      ptr0 = arg0.__destroy_into_raw();
+    }
+    wasm.__wbg_set_commitbundle_welcome(this.__wbg_ptr, ptr0);
   }
   get commit() {
     const ret = wasm.__wbg_get_commitbundle_commit(this.__wbg_ptr);
@@ -845,6 +764,15 @@ class CommitBundle {
     var ptr0 = arg0.__destroy_into_raw();
     wasm.__wbg_set_commitbundle_group_info(this.__wbg_ptr, ptr0);
   }
+  get encryptedMessage() {
+    const ret = wasm.__wbg_get_commitbundle_encryptedMessage(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;
+  }
 }
 var ConversationConfigurationFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_conversationconfiguration_free(ptr >>> 0, 1));
 
@@ -861,21 +789,22 @@ class ConversationConfiguration {
   }
   get ciphersuite() {
     const ret = wasm.__wbg_get_conversationconfiguration_ciphersuite(this.__wbg_ptr);
-    return ret === 0 ? undefined : Ciphersuite2.__wrap(ret);
+    return ret === 0 ? undefined : ret;
+  }
+  get externalSenders() {
+    const ret = wasm.__wbg_get_conversationconfiguration_externalSenders(this.__wbg_ptr);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
   }
   get custom() {
     const ret = wasm.__wbg_get_conversationconfiguration_custom(this.__wbg_ptr);
     return CustomConfiguration.__wrap(ret);
   }
   constructor(ciphersuite, external_senders, key_rotation_span, wire_policy) {
-    let ptr0 = 0;
-    if (!isLikeNone(ciphersuite)) {
-      _assertClass(ciphersuite, Ciphersuite2);
-      ptr0 = ciphersuite.__destroy_into_raw();
-    }
-    var ptr1 = isLikeNone(external_senders) ? 0 : passArrayJsValueToWasm0(external_senders, wasm.__wbindgen_malloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.conversationconfiguration_new(ptr0, ptr1, len1, isLikeNone(key_rotation_span) ? 4294967297 : key_rotation_span >>> 0, isLikeNone(wire_policy) ? 0 : wire_policy);
+    var ptr0 = isLikeNone(external_senders) ? 0 : passArrayJsValueToWasm0(external_senders, wasm.__wbindgen_malloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.conversationconfiguration_new(isLikeNone(ciphersuite) ? 0 : ciphersuite, ptr0, len0, isLikeNone(key_rotation_span) ? 4294967297 : key_rotation_span >>> 0, isLikeNone(wire_policy) ? 0 : wire_policy);
     if (ret[2]) {
       throw takeFromExternrefTable0(ret[1]);
     }
@@ -883,10 +812,39 @@ class ConversationConfiguration {
     ConversationConfigurationFinalization.register(this, this.__wbg_ptr, this);
     return this;
   }
-  get externalSenders() {
-    const ret = wasm.conversationconfiguration_externalSenders(this.__wbg_ptr);
-    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+}
+var ConversationIdFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_conversationid_free(ptr >>> 0, 1));
+
+class ConversationId {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(ConversationId.prototype);
+    obj.__wbg_ptr = ptr;
+    ConversationIdFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    ConversationIdFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_conversationid_free(ptr, 0);
+  }
+  constructor(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.clientid_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    ConversationIdFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  copyBytes() {
+    const ret = wasm.conversationid_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v1;
   }
 }
@@ -911,9 +869,7 @@ class CoreCrypto {
     wasm.__wbg_corecrypto_free(ptr, 0);
   }
   client_public_key(ciphersuite, credential_type) {
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr0 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecrypto_client_public_key(this.__wbg_ptr, ptr0, credential_type);
+    const ret = wasm.corecrypto_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
     return ret;
   }
   transaction(command) {
@@ -921,49 +877,52 @@ class CoreCrypto {
     return ret;
   }
   conversation_epoch(conversation_id) {
-    const ret = wasm.corecrypto_conversation_epoch(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecrypto_conversation_epoch(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   conversation_ciphersuite(conversation_id) {
-    const ret = wasm.corecrypto_conversation_ciphersuite(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecrypto_conversation_ciphersuite(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   conversation_exists(conversation_id) {
-    const ret = wasm.corecrypto_conversation_exists(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecrypto_conversation_exists(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   get_client_ids(conversation_id) {
-    const ret = wasm.corecrypto_get_client_ids(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecrypto_get_client_ids(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   get_external_sender(conversation_id) {
-    const ret = wasm.corecrypto_get_external_sender(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecrypto_get_external_sender(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   export_secret_key(conversation_id, key_length) {
-    const ret = wasm.corecrypto_export_secret_key(this.__wbg_ptr, conversation_id, key_length);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecrypto_export_secret_key(this.__wbg_ptr, conversation_id.__wbg_ptr, key_length);
+    return ret;
+  }
+  is_history_sharing_enabled(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecrypto_is_history_sharing_enabled(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   get_device_identities(conversation_id, device_ids) {
+    _assertClass(conversation_id, ConversationId);
     const ptr0 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecrypto_get_device_identities(this.__wbg_ptr, conversation_id, ptr0, len0);
+    const ret = wasm.corecrypto_get_device_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
   get_user_identities(conversation_id, user_ids) {
+    _assertClass(conversation_id, ConversationId);
     const ptr0 = passArrayJsValueToWasm0(user_ids, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecrypto_get_user_identities(this.__wbg_ptr, conversation_id, ptr0, len0);
-    return ret;
-  }
-  get_credential_in_use(group_info, credential_type) {
-    const ptr0 = passArray8ToWasm0(group_info, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecrypto_get_credential_in_use(this.__wbg_ptr, ptr0, len0, credential_type);
-    return ret;
-  }
-  e2ei_dump_pki_env() {
-    const ret = wasm.corecrypto_e2ei_dump_pki_env(this.__wbg_ptr);
+    const ret = wasm.corecrypto_get_user_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
   e2ei_is_pki_env_setup() {
@@ -971,9 +930,7 @@ class CoreCrypto {
     return ret;
   }
   e2ei_is_enabled(ciphersuite) {
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr0 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecrypto_e2ei_is_enabled(this.__wbg_ptr, ptr0);
+    const ret = wasm.corecrypto_e2ei_is_enabled(this.__wbg_ptr, ciphersuite);
     return ret;
   }
   register_epoch_observer(epoch_observer) {
@@ -982,6 +939,12 @@ class CoreCrypto {
     const ret = wasm.corecrypto_register_epoch_observer(this.__wbg_ptr, ptr0);
     return ret;
   }
+  register_history_observer(history_observer) {
+    _assertClass(history_observer, HistoryObserver);
+    var ptr0 = history_observer.__destroy_into_raw();
+    const ret = wasm.corecrypto_register_history_observer(this.__wbg_ptr, ptr0);
+    return ret;
+  }
   static set_logger(logger) {
     _assertClass(logger, CoreCryptoLogger);
     var ptr0 = logger.__destroy_into_raw();
@@ -1061,16 +1024,16 @@ class CoreCrypto {
     const len0 = WASM_VECTOR_LEN;
     _assertClass(key, DatabaseKey);
     var ptr1 = key.__destroy_into_raw();
-    var ptr2 = isLikeNone(client_id) ? 0 : passArray8ToWasm0(client_id, wasm.__wbindgen_malloc);
-    var len2 = WASM_VECTOR_LEN;
-    let ptr3 = 0;
-    if (!isLikeNone(ciphersuites)) {
-      _assertClass(ciphersuites, Ciphersuites);
-      ptr3 = ciphersuites.__destroy_into_raw();
+    let ptr2 = 0;
+    if (!isLikeNone(client_id)) {
+      _assertClass(client_id, ClientId);
+      ptr2 = client_id.__destroy_into_raw();
     }
+    var ptr3 = isLikeNone(ciphersuites) ? 0 : passArrayJsValueToWasm0(ciphersuites, wasm.__wbindgen_malloc);
+    var len3 = WASM_VECTOR_LEN;
     var ptr4 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm.__wbindgen_malloc);
     var len4 = WASM_VECTOR_LEN;
-    const ret = wasm.corecrypto_async_new(ptr0, len0, ptr1, ptr2, len2, ptr3, ptr4, len4, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
+    const ret = wasm.corecrypto_async_new(ptr0, len0, ptr1, ptr2, ptr3, len3, ptr4, len4, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
     return ret;
   }
   static deferred_init(path, key, entropy_seed) {
@@ -1088,14 +1051,10 @@ class CoreCrypto {
     const ret = wasm.corecrypto_close(ptr);
     return ret;
   }
-  can_close() {
-    const ret = wasm.corecrypto_can_close(this.__wbg_ptr);
-    return ret;
-  }
   static history_client(history_secret) {
-    const ptr0 = passArray8ToWasm0(history_secret, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecrypto_history_client(ptr0, len0);
+    _assertClass(history_secret, HistorySecret);
+    var ptr0 = history_secret.__destroy_into_raw();
+    const ret = wasm.corecrypto_history_client(ptr0);
     return ret;
   }
 }
@@ -1128,9 +1087,7 @@ class CoreCryptoContext {
     const len2 = WASM_VECTOR_LEN;
     var ptr3 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len3 = WASM_VECTOR_LEN;
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr4 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_e2ei_new_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, expiry_sec, ptr4);
+    const ret = wasm.corecryptocontext_e2ei_new_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, expiry_sec, ciphersuite);
     return ret;
   }
   e2ei_new_activation_enrollment(display_name, handle, team, expiry_sec, ciphersuite) {
@@ -1140,9 +1097,7 @@ class CoreCryptoContext {
     const len1 = WASM_VECTOR_LEN;
     var ptr2 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len2 = WASM_VECTOR_LEN;
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr3 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_e2ei_new_activation_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ptr3);
+    const ret = wasm.corecryptocontext_e2ei_new_activation_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ciphersuite);
     return ret;
   }
   e2ei_new_rotate_enrollment(display_name, handle, team, expiry_sec, ciphersuite) {
@@ -1152,9 +1107,7 @@ class CoreCryptoContext {
     var len1 = WASM_VECTOR_LEN;
     var ptr2 = isLikeNone(team) ? 0 : passStringToWasm0(team, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     var len2 = WASM_VECTOR_LEN;
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr3 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_e2ei_new_rotate_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ptr3);
+    const ret = wasm.corecryptocontext_e2ei_new_rotate_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_sec, ciphersuite);
     return ret;
   }
   e2ei_register_acme_ca(trust_anchor_pem) {
@@ -1186,7 +1139,8 @@ class CoreCryptoContext {
     return ret;
   }
   e2ei_rotate(conversation_id) {
-    const ret = wasm.corecryptocontext_e2ei_rotate(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_e2ei_rotate(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   save_x509_credential(enrollment, certificate_chain) {
@@ -1198,9 +1152,7 @@ class CoreCryptoContext {
     return ret;
   }
   delete_stale_key_packages(ciphersuite) {
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr0 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_delete_stale_key_packages(this.__wbg_ptr, ptr0);
+    const ret = wasm.corecryptocontext_delete_stale_key_packages(this.__wbg_ptr, ciphersuite);
     return ret;
   }
   e2ei_enrollment_stash(enrollment) {
@@ -1216,35 +1168,26 @@ class CoreCryptoContext {
     return ret;
   }
   e2ei_conversation_state(conversation_id) {
-    const ret = wasm.corecryptocontext_e2ei_conversation_state(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_e2ei_conversation_state(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   e2ei_is_enabled(ciphersuite) {
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr0 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_e2ei_is_enabled(this.__wbg_ptr, ptr0);
+    const ret = wasm.corecryptocontext_e2ei_is_enabled(this.__wbg_ptr, ciphersuite);
     return ret;
   }
   get_device_identities(conversation_id, device_ids) {
+    _assertClass(conversation_id, ConversationId);
     const ptr0 = passArrayJsValueToWasm0(device_ids, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_get_device_identities(this.__wbg_ptr, conversation_id, ptr0, len0);
+    const ret = wasm.corecryptocontext_get_device_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
   get_user_identities(conversation_id, user_ids) {
+    _assertClass(conversation_id, ConversationId);
     const ptr0 = passArrayJsValueToWasm0(user_ids, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_get_user_identities(this.__wbg_ptr, conversation_id, ptr0, len0);
-    return ret;
-  }
-  get_credential_in_use(group_info, credential_type) {
-    const ptr0 = passArray8ToWasm0(group_info, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_get_credential_in_use(this.__wbg_ptr, ptr0, len0, credential_type);
-    return ret;
-  }
-  e2ei_dump_pki_env() {
-    const ret = wasm.corecryptocontext_e2ei_dump_pki_env(this.__wbg_ptr);
+    const ret = wasm.corecryptocontext_get_user_identities(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
   e2ei_is_pki_env_setup() {
@@ -1254,135 +1197,133 @@ class CoreCryptoContext {
   mls_init(client_id, ciphersuites, nb_key_package) {
     _assertClass(client_id, ClientId);
     var ptr0 = client_id.__destroy_into_raw();
-    _assertClass(ciphersuites, Ciphersuites);
-    var ptr1 = ciphersuites.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_mls_init(this.__wbg_ptr, ptr0, ptr1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
-    return ret;
-  }
-  mls_generate_keypairs(ciphersuites) {
-    _assertClass(ciphersuites, Ciphersuites);
-    var ptr0 = ciphersuites.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_mls_generate_keypairs(this.__wbg_ptr, ptr0);
-    return ret;
-  }
-  mls_init_with_client_id(client_id, tmp_client_ids, ciphersuites) {
-    _assertClass(client_id, ClientId);
-    var ptr0 = client_id.__destroy_into_raw();
-    const ptr1 = passArrayJsValueToWasm0(tmp_client_ids, wasm.__wbindgen_malloc);
+    const ptr1 = passArrayJsValueToWasm0(ciphersuites, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    _assertClass(ciphersuites, Ciphersuites);
-    var ptr2 = ciphersuites.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_mls_init_with_client_id(this.__wbg_ptr, ptr0, ptr1, len1, ptr2);
+    const ret = wasm.corecryptocontext_mls_init(this.__wbg_ptr, ptr0, ptr1, len1, isLikeNone(nb_key_package) ? 4294967297 : nb_key_package >>> 0);
     return ret;
   }
   client_public_key(ciphersuite, credential_type) {
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr0 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_client_public_key(this.__wbg_ptr, ptr0, credential_type);
+    const ret = wasm.corecryptocontext_client_public_key(this.__wbg_ptr, ciphersuite, credential_type);
     return ret;
   }
   conversation_epoch(conversation_id) {
-    const ret = wasm.corecryptocontext_conversation_epoch(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_conversation_epoch(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   conversation_ciphersuite(conversation_id) {
-    const ret = wasm.corecryptocontext_conversation_ciphersuite(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_conversation_ciphersuite(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   conversation_exists(conversation_id) {
-    const ret = wasm.corecryptocontext_conversation_exists(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_conversation_exists(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   get_client_ids(conversation_id) {
-    const ret = wasm.corecryptocontext_get_client_ids(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_get_client_ids(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   export_secret_key(conversation_id, key_length) {
-    const ret = wasm.corecryptocontext_export_secret_key(this.__wbg_ptr, conversation_id, key_length);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_export_secret_key(this.__wbg_ptr, conversation_id.__wbg_ptr, key_length);
     return ret;
   }
   get_external_sender(conversation_id) {
-    const ret = wasm.corecryptocontext_get_external_sender(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_get_external_sender(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   client_keypackages(ciphersuite, credential_type, amount_requested) {
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr0 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_client_keypackages(this.__wbg_ptr, ptr0, credential_type, amount_requested);
+    const ret = wasm.corecryptocontext_client_keypackages(this.__wbg_ptr, ciphersuite, credential_type, amount_requested);
     return ret;
   }
   client_valid_keypackages_count(ciphersuite, credential_type) {
-    _assertClass(ciphersuite, Ciphersuite2);
-    var ptr0 = ciphersuite.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_client_valid_keypackages_count(this.__wbg_ptr, ptr0, credential_type);
-    return ret;
-  }
-  delete_keypackages(refs) {
-    _assertClass(refs, ArrayOfByteArray);
-    var ptr0 = refs.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_delete_keypackages(this.__wbg_ptr, ptr0);
+    const ret = wasm.corecryptocontext_client_valid_keypackages_count(this.__wbg_ptr, ciphersuite, credential_type);
     return ret;
   }
   create_conversation(conversation_id, creator_credential_type, config) {
+    _assertClass(conversation_id, ConversationId);
     _assertClass(config, ConversationConfiguration);
     var ptr0 = config.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_create_conversation(this.__wbg_ptr, conversation_id, creator_credential_type, ptr0);
+    const ret = wasm.corecryptocontext_create_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, creator_credential_type, ptr0);
     return ret;
   }
   process_welcome_message(welcome_message, custom_configuration) {
-    const ptr0 = passArray8ToWasm0(welcome_message, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
+    _assertClass(welcome_message, Welcome);
+    var ptr0 = welcome_message.__destroy_into_raw();
     _assertClass(custom_configuration, CustomConfiguration);
     var ptr1 = custom_configuration.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_process_welcome_message(this.__wbg_ptr, ptr0, len0, ptr1);
+    const ret = wasm.corecryptocontext_process_welcome_message(this.__wbg_ptr, ptr0, ptr1);
     return ret;
   }
   add_clients_to_conversation(conversation_id, key_packages) {
-    _assertClass(key_packages, ArrayOfByteArray);
-    var ptr0 = key_packages.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_add_clients_to_conversation(this.__wbg_ptr, conversation_id, ptr0);
+    _assertClass(conversation_id, ConversationId);
+    const ptr0 = passArrayJsValueToWasm0(key_packages, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.corecryptocontext_add_clients_to_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
   remove_clients_from_conversation(conversation_id, clients) {
+    _assertClass(conversation_id, ConversationId);
     const ptr0 = passArrayJsValueToWasm0(clients, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_remove_clients_from_conversation(this.__wbg_ptr, conversation_id, ptr0, len0);
+    const ret = wasm.corecryptocontext_remove_clients_from_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
   mark_conversation_as_child_of(child_id, parent_id) {
-    const ret = wasm.corecryptocontext_mark_conversation_as_child_of(this.__wbg_ptr, child_id, parent_id);
+    _assertClass(child_id, ConversationId);
+    _assertClass(parent_id, ConversationId);
+    const ret = wasm.corecryptocontext_mark_conversation_as_child_of(this.__wbg_ptr, child_id.__wbg_ptr, parent_id.__wbg_ptr);
     return ret;
   }
   update_keying_material(conversation_id) {
-    const ret = wasm.corecryptocontext_update_keying_material(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_update_keying_material(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   commit_pending_proposals(conversation_id) {
-    const ret = wasm.corecryptocontext_commit_pending_proposals(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_commit_pending_proposals(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   wipe_conversation(conversation_id) {
-    const ret = wasm.corecryptocontext_wipe_conversation(this.__wbg_ptr, conversation_id);
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_wipe_conversation(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   decrypt_message(conversation_id, payload) {
+    _assertClass(conversation_id, ConversationId);
     const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_decrypt_message(this.__wbg_ptr, conversation_id, ptr0, len0);
+    const ret = wasm.corecryptocontext_decrypt_message(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
   encrypt_message(conversation_id, message) {
+    _assertClass(conversation_id, ConversationId);
     const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.corecryptocontext_encrypt_message(this.__wbg_ptr, conversation_id, ptr0, len0);
+    const ret = wasm.corecryptocontext_encrypt_message(this.__wbg_ptr, conversation_id.__wbg_ptr, ptr0, len0);
     return ret;
   }
   join_by_external_commit(group_info, custom_configuration, credential_type) {
-    const ptr0 = passArray8ToWasm0(group_info, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
+    _assertClass(group_info, GroupInfo);
+    var ptr0 = group_info.__destroy_into_raw();
     _assertClass(custom_configuration, CustomConfiguration);
     var ptr1 = custom_configuration.__destroy_into_raw();
-    const ret = wasm.corecryptocontext_join_by_external_commit(this.__wbg_ptr, ptr0, len0, ptr1, credential_type);
+    const ret = wasm.corecryptocontext_join_by_external_commit(this.__wbg_ptr, ptr0, ptr1, credential_type);
+    return ret;
+  }
+  enable_history_sharing(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_enable_history_sharing(this.__wbg_ptr, conversation_id.__wbg_ptr);
+    return ret;
+  }
+  disable_history_sharing(conversation_id) {
+    _assertClass(conversation_id, ConversationId);
+    const ret = wasm.corecryptocontext_disable_history_sharing(this.__wbg_ptr, conversation_id.__wbg_ptr);
     return ret;
   }
   proteus_init() {
@@ -1718,51 +1659,11 @@ class DecryptedMessage {
   }
   get crlNewDistributionPoints() {
     const ret = wasm.__wbg_get_decryptedmessage_crlNewDistributionPoints(this.__wbg_ptr);
-    return NewCrlDistributionPoints.__wrap(ret);
-  }
-}
-var E2eiDumpedPkiEnvFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_e2eidumpedpkienv_free(ptr >>> 0, 1));
-
-class E2eiDumpedPkiEnv {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(E2eiDumpedPkiEnv.prototype);
-    obj.__wbg_ptr = ptr;
-    E2eiDumpedPkiEnvFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    E2eiDumpedPkiEnvFinalization.unregister(this);
-    return ptr;
-  }
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_e2eidumpedpkienv_free(ptr, 0);
-  }
-  get root_ca() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-      const ret = wasm.__wbg_get_e2eidumpedpkienv_root_ca(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);
+    let v1;
+    if (ret[0] !== 0) {
+      v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+      wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
     }
-  }
-  get intermediates() {
-    const ret = wasm.__wbg_get_e2eidumpedpkienv_intermediates(this.__wbg_ptr);
-    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v1;
-  }
-  get crls() {
-    const ret = wasm.__wbg_get_e2eidumpedpkienv_crls(this.__wbg_ptr);
-    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
     return v1;
   }
 }
@@ -1789,6 +1690,47 @@ class EpochObserver {
     return this;
   }
 }
+var ExternalSenderKeyFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_externalsenderkey_free(ptr >>> 0, 1));
+
+class ExternalSenderKey {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(ExternalSenderKey.prototype);
+    obj.__wbg_ptr = ptr;
+    ExternalSenderKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  static __unwrap(jsValue) {
+    if (!(jsValue instanceof ExternalSenderKey)) {
+      return 0;
+    }
+    return jsValue.__destroy_into_raw();
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    ExternalSenderKeyFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_externalsenderkey_free(ptr, 0);
+  }
+  constructor(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.clientid_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    ExternalSenderKeyFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  copyBytes() {
+    const ret = wasm.externalsenderkey_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+}
 var FfiWireE2EIdentityFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_ffiwiree2eidentity_free(ptr >>> 0, 1));
 
 class FfiWireE2EIdentity {
@@ -1920,6 +1862,41 @@ class FfiWireE2EIdentity {
     return ret;
   }
 }
+var GroupInfoFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_groupinfo_free(ptr >>> 0, 1));
+
+class GroupInfo {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(GroupInfo.prototype);
+    obj.__wbg_ptr = ptr;
+    GroupInfoFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    GroupInfoFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_groupinfo_free(ptr, 0);
+  }
+  constructor(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.clientid_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    GroupInfoFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  copyBytes() {
+    const ret = wasm.groupinfo_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+}
 var GroupInfoBundleFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_groupinfobundle_free(ptr >>> 0, 1));
 
 class GroupInfoBundle {
@@ -1956,14 +1933,120 @@ class GroupInfoBundle {
   }
   get payload() {
     const ret = wasm.__wbg_get_groupinfobundle_payload(this.__wbg_ptr);
+    return GroupInfo.__wrap(ret);
+  }
+  set payload(arg0) {
+    _assertClass(arg0, GroupInfo);
+    var ptr0 = arg0.__destroy_into_raw();
+    wasm.__wbg_set_groupinfobundle_payload(this.__wbg_ptr, ptr0);
+  }
+}
+var HistoryObserverFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_historyobserver_free(ptr >>> 0, 1));
+
+class HistoryObserver {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    HistoryObserverFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_historyobserver_free(ptr, 0);
+  }
+  constructor(this_context, history_client_created) {
+    const ret = wasm.historyobserver_new(this_context, history_client_created);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    HistoryObserverFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+}
+var HistorySecretFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_historysecret_free(ptr >>> 0, 1));
+
+class HistorySecret {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(HistorySecret.prototype);
+    obj.__wbg_ptr = ptr;
+    HistorySecretFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    HistorySecretFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_historysecret_free(ptr, 0);
+  }
+  get clientId() {
+    const ret = wasm.__wbg_get_historysecret_clientId(this.__wbg_ptr);
+    return ClientId.__wrap(ret);
+  }
+  get data() {
+    const ret = wasm.__wbg_get_historysecret_data(this.__wbg_ptr);
     var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v1;
   }
-  set payload(arg0) {
-    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
+  constructor(client_id, data) {
+    _assertClass(client_id, ClientId);
+    var ptr0 = client_id.__destroy_into_raw();
+    const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.historysecret_new(ptr0, ptr1, len1);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    this.__wbg_ptr = ret[0] >>> 0;
+    HistorySecretFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+}
+var KeyPackageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_keypackage_free(ptr >>> 0, 1));
+
+class KeyPackage {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(KeyPackage.prototype);
+    obj.__wbg_ptr = ptr;
+    KeyPackageFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  static __unwrap(jsValue) {
+    if (!(jsValue instanceof KeyPackage)) {
+      return 0;
+    }
+    return jsValue.__destroy_into_raw();
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    KeyPackageFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_keypackage_free(ptr, 0);
+  }
+  constructor(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_commitbundle_commit(this.__wbg_ptr, ptr0, len0);
+    const ret = wasm.clientid_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    KeyPackageFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  copyBytes() {
+    const ret = wasm.keypackage_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
   }
 }
 var MlsTransportFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_mlstransport_free(ptr >>> 0, 1));
@@ -1979,8 +2062,8 @@ class MlsTransport {
     const ptr = this.__destroy_into_raw();
     wasm.__wbg_mlstransport_free(ptr, 0);
   }
-  constructor(this_context, send_commit_bundle, send_message) {
-    const ret = wasm.mlstransport_new(this_context, send_commit_bundle, send_message);
+  constructor(this_context, send_commit_bundle, send_message, prepare_for_transport) {
+    const ret = wasm.mlstransport_new(this_context, send_commit_bundle, send_message, prepare_for_transport);
     if (ret[2]) {
       throw takeFromExternrefTable0(ret[1]);
     }
@@ -1989,6 +2072,34 @@ class MlsTransport {
     return this;
   }
 }
+var MlsTransportDataFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_mlstransportdata_free(ptr >>> 0, 1));
+
+class MlsTransportData {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    MlsTransportDataFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_mlstransportdata_free(ptr, 0);
+  }
+  get data() {
+    const ret = wasm.__wbg_get_mlstransportdata_data(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  constructor(buf) {
+    const ptr0 = passArray8ToWasm0(buf, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mlstransportdata_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    MlsTransportDataFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+}
 var MlsTransportResponseFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_mlstransportresponse_free(ptr >>> 0, 1));
 
 class MlsTransportResponse {
@@ -2120,62 +2231,102 @@ class NewAcmeOrder {
     return v1;
   }
 }
-var NewCrlDistributionPointsFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_newcrldistributionpoints_free(ptr >>> 0, 1));
+var ProteusAutoPrekeyBundleFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_proteusautoprekeybundle_free(ptr >>> 0, 1));
 
-class NewCrlDistributionPoints {
+class ProteusAutoPrekeyBundle {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
-    const obj = Object.create(NewCrlDistributionPoints.prototype);
+    const obj = Object.create(ProteusAutoPrekeyBundle.prototype);
     obj.__wbg_ptr = ptr;
-    NewCrlDistributionPointsFinalization.register(obj, obj.__wbg_ptr, obj);
+    ProteusAutoPrekeyBundleFinalization.register(obj, obj.__wbg_ptr, obj);
     return obj;
   }
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    NewCrlDistributionPointsFinalization.unregister(this);
+    ProteusAutoPrekeyBundleFinalization.unregister(this);
     return ptr;
   }
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_newcrldistributionpoints_free(ptr, 0);
+    wasm.__wbg_proteusautoprekeybundle_free(ptr, 0);
   }
-  as_strings() {
-    const ret = wasm.newcrldistributionpoints_as_strings(this.__wbg_ptr);
-    let v1;
-    if (ret[0] !== 0) {
-      v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-      wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    }
+  get id() {
+    const ret = wasm.__wbg_get_proteusautoprekeybundle_id(this.__wbg_ptr);
+    return ret;
+  }
+  get pkb() {
+    const ret = wasm.__wbg_get_proteusautoprekeybundle_pkb(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v1;
   }
 }
-var ProteusAutoPrekeyBundleFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_proteusautoprekeybundle_free(ptr >>> 0, 1));
+var SecretKeyFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_secretkey_free(ptr >>> 0, 1));
 
-class ProteusAutoPrekeyBundle {
+class SecretKey {
   static __wrap(ptr) {
     ptr = ptr >>> 0;
-    const obj = Object.create(ProteusAutoPrekeyBundle.prototype);
+    const obj = Object.create(SecretKey.prototype);
     obj.__wbg_ptr = ptr;
-    ProteusAutoPrekeyBundleFinalization.register(obj, obj.__wbg_ptr, obj);
+    SecretKeyFinalization.register(obj, obj.__wbg_ptr, obj);
     return obj;
   }
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
-    ProteusAutoPrekeyBundleFinalization.unregister(this);
+    SecretKeyFinalization.unregister(this);
     return ptr;
   }
   free() {
     const ptr = this.__destroy_into_raw();
-    wasm.__wbg_proteusautoprekeybundle_free(ptr, 0);
+    wasm.__wbg_secretkey_free(ptr, 0);
   }
-  get id() {
-    const ret = wasm.__wbg_get_proteusautoprekeybundle_id(this.__wbg_ptr);
-    return ret;
+  constructor(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.clientid_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    SecretKeyFinalization.register(this, this.__wbg_ptr, this);
+    return this;
   }
-  get pkb() {
-    const ret = wasm.__wbg_get_proteusautoprekeybundle_pkb(this.__wbg_ptr);
+  copyBytes() {
+    const ret = wasm.secretkey_copyBytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+}
+var WelcomeFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry((ptr) => wasm.__wbg_welcome_free(ptr >>> 0, 1));
+
+class Welcome {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(Welcome.prototype);
+    obj.__wbg_ptr = ptr;
+    WelcomeFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    WelcomeFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_welcome_free(ptr, 0);
+  }
+  constructor(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.clientid_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    WelcomeFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  copyBytes() {
+    const ret = wasm.welcome_copyBytes(this.__wbg_ptr);
     var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
     return v1;
@@ -2203,9 +2354,7 @@ class WelcomeBundle {
   }
   get id() {
     const ret = wasm.__wbg_get_welcomebundle_id(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
+    return ConversationId.__wrap(ret);
   }
   get crlNewDistributionPoints() {
     const ret = wasm.__wbg_get_welcomebundle_crlNewDistributionPoints(this.__wbg_ptr);
@@ -2309,16 +2458,11 @@ class X509Identity {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
-  set handle(arg0) {
-    const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_x509identity_handle(this.__wbg_ptr, ptr0, len0);
-  }
-  get display_name() {
+  get displayName() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const ret = wasm.__wbg_get_x509identity_display_name(this.__wbg_ptr);
+      const ret = wasm.__wbg_get_x509identity_displayName(this.__wbg_ptr);
       deferred1_0 = ret[0];
       deferred1_1 = ret[1];
       return getStringFromWasm0(ret[0], ret[1]);
@@ -2326,11 +2470,6 @@ class X509Identity {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
-  set display_name(arg0) {
-    const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_x509identity_display_name(this.__wbg_ptr, ptr0, len0);
-  }
   get domain() {
     let deferred1_0;
     let deferred1_1;
@@ -2343,11 +2482,6 @@ class X509Identity {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
-  set domain(arg0) {
-    const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_x509identity_domain(this.__wbg_ptr, ptr0, len0);
-  }
   get certificate() {
     let deferred1_0;
     let deferred1_1;
@@ -2360,16 +2494,11 @@ class X509Identity {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
-  set certificate(arg0) {
-    const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_x509identity_certificate(this.__wbg_ptr, ptr0, len0);
-  }
-  get serial_number() {
+  get serialNumber() {
     let deferred1_0;
     let deferred1_1;
     try {
-      const ret = wasm.__wbg_get_x509identity_serial_number(this.__wbg_ptr);
+      const ret = wasm.__wbg_get_x509identity_serialNumber(this.__wbg_ptr);
       deferred1_0 = ret[0];
       deferred1_1 = ret[1];
       return getStringFromWasm0(ret[0], ret[1]);
@@ -2377,25 +2506,14 @@ class X509Identity {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
-  set serial_number(arg0) {
-    const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_x509identity_serial_number(this.__wbg_ptr, ptr0, len0);
-  }
-  get not_before() {
-    const ret = wasm.__wbg_get_x509identity_not_before(this.__wbg_ptr);
+  get notBefore() {
+    const ret = wasm.__wbg_get_x509identity_notBefore(this.__wbg_ptr);
     return BigInt.asUintN(64, ret);
   }
-  set not_before(arg0) {
-    wasm.__wbg_set_x509identity_not_before(this.__wbg_ptr, arg0);
-  }
-  get not_after() {
-    const ret = wasm.__wbg_get_x509identity_not_after(this.__wbg_ptr);
+  get notAfter() {
+    const ret = wasm.__wbg_get_x509identity_notAfter(this.__wbg_ptr);
     return BigInt.asUintN(64, ret);
   }
-  set not_after(arg0) {
-    wasm.__wbg_set_x509identity_not_after(this.__wbg_ptr, arg0);
-  }
 }
 async function __wbg_load(module, imports) {
   if (typeof Response === "function" && module instanceof Response) {
@@ -2440,10 +2558,6 @@ function __wbg_get_imports() {
       arg0.advance(arg1 >>> 0);
     }, arguments);
   };
-  imports.wbg.__wbg_arrayofbytearray_new = function(arg0) {
-    const ret = ArrayOfByteArray.__wrap(arg0);
-    return ret;
-  };
   imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
     const ret = arg0.buffer;
     return ret;
@@ -2476,10 +2590,6 @@ function __wbg_get_imports() {
       return ret;
     }, arguments);
   };
-  imports.wbg.__wbg_ciphersuite_new = function(arg0) {
-    const ret = Ciphersuite2.__wrap(arg0);
-    return ret;
-  };
   imports.wbg.__wbg_clientid_new = function(arg0) {
     const ret = ClientId.__wrap(arg0);
     return ret;
@@ -2505,6 +2615,10 @@ function __wbg_get_imports() {
       arg0.continue();
     }, arguments);
   };
+  imports.wbg.__wbg_conversationid_new = function(arg0) {
+    const ret = ConversationId.__wrap(arg0);
+    return ret;
+  };
   imports.wbg.__wbg_corecrypto_new = function(arg0) {
     const ret = CoreCrypto.__wrap(arg0);
     return ret;
@@ -2571,10 +2685,6 @@ function __wbg_get_imports() {
     const ret = arg0.done;
     return ret;
   };
-  imports.wbg.__wbg_e2eidumpedpkienv_new = function(arg0) {
-    const ret = E2eiDumpedPkiEnv.__wrap(arg0);
-    return ret;
-  };
   imports.wbg.__wbg_entries_3265d4158b33e5dc = function(arg0) {
     const ret = Object.entries(arg0);
     return ret;
@@ -2603,12 +2713,20 @@ function __wbg_get_imports() {
       return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     }, arguments);
   };
-  imports.wbg.__wbg_execute_e5908b12cc404225 = function() {
+  imports.wbg.__wbg_execute_804dc51b94ff3c62 = function() {
     return handleError(function(arg0, arg1) {
       const ret = arg0.execute(CoreCryptoContext.__wrap(arg1));
       return ret;
     }, arguments);
   };
+  imports.wbg.__wbg_externalsenderkey_new = function(arg0) {
+    const ret = ExternalSenderKey.__wrap(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_externalsenderkey_unwrap = function(arg0) {
+    const ret = ExternalSenderKey.__unwrap(arg0);
+    return ret;
+  };
   imports.wbg.__wbg_ffiwiree2eidentity_new = function(arg0) {
     const ret = FfiWireE2EIdentity.__wrap(arg0);
     return ret;
@@ -2631,7 +2749,7 @@ function __wbg_get_imports() {
       return ret;
     }, arguments);
   };
-  imports.wbg.__wbg_getRandomValues_3d90134a348e46b3 = function() {
+  imports.wbg.__wbg_getRandomValues_38097e921c2494c3 = function() {
     return handleError(function(arg0, arg1) {
       globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
     }, arguments);
@@ -2678,6 +2796,10 @@ function __wbg_get_imports() {
     const ret = arg0[arg1];
     return ret;
   };
+  imports.wbg.__wbg_historysecret_new = function(arg0) {
+    const ret = HistorySecret.__wrap(arg0);
+    return ret;
+  };
   imports.wbg.__wbg_indexNames_0ed82a19d7d88aa3 = function(arg0) {
     const ret = arg0.indexNames;
     return ret;
@@ -2812,6 +2934,14 @@ function __wbg_get_imports() {
       return ret;
     }, arguments);
   };
+  imports.wbg.__wbg_keypackage_new = function(arg0) {
+    const ret = KeyPackage.__wrap(arg0);
+    return ret;
+  };
+  imports.wbg.__wbg_keypackage_unwrap = function(arg0) {
+    const ret = KeyPackage.__unwrap(arg0);
+    return ret;
+  };
   imports.wbg.__wbg_length_52b6c4580c5ec934 = function(arg0) {
     const ret = arg0.length;
     return ret;
@@ -2854,7 +2984,7 @@ function __wbg_get_imports() {
         const a = state0.a;
         state0.a = 0;
         try {
-          return __wbg_adapter_555(a, state0.b, arg02, arg12);
+          return __wbg_adapter_565(a, state0.b, arg02, arg12);
         } finally {
           state0.a = a;
         }
@@ -2897,10 +3027,6 @@ function __wbg_get_imports() {
     const ret = NewAcmeOrder.__wrap(arg0);
     return ret;
   };
-  imports.wbg.__wbg_newcrldistributionpoints_new = function(arg0) {
-    const ret = NewCrlDistributionPoints.__wrap(arg0);
-    return ret;
-  };
   imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
     const ret = new Function(getStringFromWasm0(arg0, arg1));
     return ret;
@@ -3031,6 +3157,10 @@ function __wbg_get_imports() {
       return ret;
     }, arguments);
   };
+  imports.wbg.__wbg_secretkey_new = function(arg0) {
+    const ret = SecretKey.__wrap(arg0);
+    return ret;
+  };
   imports.wbg.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
     arg0[arg1 >>> 0] = arg2;
   };
@@ -3205,16 +3335,16 @@ function __wbg_get_imports() {
     const ret = false;
     return ret;
   };
-  imports.wbg.__wbindgen_closure_wrapper14695 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2665, __wbg_adapter_63);
+  imports.wbg.__wbindgen_closure_wrapper14671 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 2638, __wbg_adapter_65);
     return ret;
   };
-  imports.wbg.__wbindgen_closure_wrapper15853 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2865, __wbg_adapter_66);
+  imports.wbg.__wbindgen_closure_wrapper15902 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 2840, __wbg_adapter_68);
     return ret;
   };
-  imports.wbg.__wbindgen_closure_wrapper4518 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 972, __wbg_adapter_60);
+  imports.wbg.__wbindgen_closure_wrapper4580 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 964, __wbg_adapter_62);
     return ret;
   };
   imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
@@ -3303,6 +3433,16 @@ function __wbg_get_imports() {
   imports.wbg.__wbindgen_throw = function(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
   };
+  imports.wbg.__wbindgen_try_into_number = function(arg0) {
+    let result;
+    try {
+      result = +arg0;
+    } catch (e) {
+      result = e;
+    }
+    const ret = result;
+    return ret;
+  };
   imports.wbg.__wbindgen_uint8_array_new = function(arg0, arg1) {
     var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
     wasm.__wbindgen_free(arg0, arg1 * 1, 1);
@@ -3316,7 +3456,6 @@ function __wbg_finalize_init(instance, module) {
   wasm = instance.exports;
   __wbg_init.__wbindgen_wasm_module = module;
   cachedDataViewMemory0 = null;
-  cachedUint16ArrayMemory0 = null;
   cachedUint8ArrayMemory0 = null;
   wasm.__wbindgen_start();
   return wasm;
@@ -3361,7 +3500,8 @@ function commitBundleFromFfi(commitBundle) {
       encryptionType: commitBundle.group_info.encryption_type,
       ratchetTreeType: commitBundle.group_info.ratchet_tree_type,
       payload: commitBundle.group_info.payload
-    }
+    },
+    encryptedMessage: commitBundle.encryptedMessage
   };
 }
 function decryptedMessageFromFfi(m) {
@@ -3375,10 +3515,10 @@ function bufferedDecryptedMessageFromFfi(m) {
     message: m.message,
     isActive: m.isActive,
     commitDelay: m.commitDelay ? safeBigintToNumber(m.commitDelay) : undefined,
-    senderClientId: m.senderClientId?.as_bytes(),
+    senderClientId: m.senderClientId,
     hasEpochChanged: m.hasEpochChanged,
     identity: m.identity,
-    crlNewDistributionPoints: m.crlNewDistributionPoints.as_strings()
+    crlNewDistributionPoints: m.crlNewDistributionPoints
   };
 }
 function mapTransportResponseToFfi(response) {
@@ -3409,10 +3549,13 @@ class MlsTransportFfiShim {
     const response = await this.inner.sendMessage(message);
     return mapTransportResponseToFfi(response);
   }
+  async prepareForTransport(secret) {
+    return await this.inner.prepareForTransport(secret);
+  }
 }
 function mlsTransportToFfi(mlsTransport) {
   const shim = new MlsTransportFfiShim(mlsTransport);
-  return new MlsTransport(shim, shim.sendCommitBundle, shim.sendMessage);
+  return new MlsTransport(shim, shim.sendCommitBundle, shim.sendMessage, shim.prepareForTransport);
 }
 
 // src/CoreCryptoE2EI.ts
@@ -3501,8 +3644,7 @@ var E2eiConversationState2;
 
 // src/ConversationConfiguration.ts
 function conversationConfigurationToFfi(cc) {
-  const ciphersuite = cc.ciphersuite ? new Ciphersuite2(cc.ciphersuite) : null;
-  return new ConversationConfiguration(ciphersuite, cc.externalSenders, cc.keyRotationSpan, cc.wirePolicy);
+  return new ConversationConfiguration(cc.ciphersuite, cc.externalSenders, cc.keyRotationSpan, cc.wirePolicy);
 }
 
 // src/CoreCryptoContext.ts
@@ -3521,20 +3663,7 @@ class CoreCryptoContext2 {
     return await CoreCryptoError.asyncMapErr(this.#ctx.get_data());
   }
   async mlsInit(clientId, ciphersuites, nbKeyPackage) {
-    const id = new ClientId(clientId);
-    const cs = new Ciphersuites(Uint16Array.from(ciphersuites.map((cs2) => cs2.valueOf())));
-    return await CoreCryptoError.asyncMapErr(this.#ctx.mls_init(id, cs, nbKeyPackage));
-  }
-  async mlsGenerateKeypair(ciphersuites) {
-    const cs = new Ciphersuites(Uint16Array.from(ciphersuites.map((cs2) => cs2.valueOf())));
-    const kps = await CoreCryptoError.asyncMapErr(this.#ctx.mls_generate_keypairs(cs));
-    return kps.map((kp) => kp.as_bytes());
-  }
-  async mlsInitWithClientId(clientId, signaturePublicKeys, ciphersuites) {
-    const id = new ClientId(clientId);
-    const pks = signaturePublicKeys.map((pk) => new ClientId(pk));
-    const cs = new Ciphersuites(Uint16Array.from(ciphersuites.map((cs2) => cs2.valueOf())));
-    return await CoreCryptoError.asyncMapErr(this.#ctx.mls_init_with_client_id(id, pks, cs));
+    return await CoreCryptoError.asyncMapErr(this.#ctx.mls_init(clientId, ciphersuites, nbKeyPackage));
   }
   async conversationExists(conversationId) {
     return await CoreCryptoError.asyncMapErr(this.#ctx.conversation_exists(conversationId));
@@ -3548,7 +3677,7 @@ class CoreCryptoContext2 {
   }
   async conversationCiphersuite(conversationId) {
     const cs = await CoreCryptoError.asyncMapErr(this.#ctx.conversation_ciphersuite(conversationId));
-    return cs.as_u16();
+    return cs;
   }
   async wipeConversation(conversationId) {
     return await CoreCryptoError.asyncMapErr(this.#ctx.wipe_conversation(conversationId));
@@ -3573,31 +3702,22 @@ class CoreCryptoContext2 {
     return await CoreCryptoError.asyncMapErr(this.#ctx.process_welcome_message(welcomeMessage, config));
   }
   async clientPublicKey(ciphersuite, credentialType) {
-    const cs = new Ciphersuite2(ciphersuite);
-    return await CoreCryptoError.asyncMapErr(this.#ctx.client_public_key(cs, credentialType));
+    return await CoreCryptoError.asyncMapErr(this.#ctx.client_public_key(ciphersuite, credentialType));
   }
   async clientValidKeypackagesCount(ciphersuite, credentialType) {
-    const cs = new Ciphersuite2(ciphersuite);
-    const kpCount = await CoreCryptoError.asyncMapErr(this.#ctx.client_valid_keypackages_count(cs, credentialType));
+    const kpCount = await CoreCryptoError.asyncMapErr(this.#ctx.client_valid_keypackages_count(ciphersuite, credentialType));
     return safeBigintToNumber(kpCount);
   }
   async clientKeypackages(ciphersuite, credentialType, amountRequested) {
-    const cs = new Ciphersuite2(ciphersuite);
-    const kps = await CoreCryptoError.asyncMapErr(this.#ctx.client_keypackages(cs, credentialType, amountRequested));
-    return kps.as_arrays();
-  }
-  async deleteKeypackages(refs) {
-    const aobaRefs = new ArrayOfByteArray(refs);
-    return await CoreCryptoError.asyncMapErr(this.#ctx.delete_keypackages(aobaRefs));
+    const kps = await CoreCryptoError.asyncMapErr(this.#ctx.client_keypackages(ciphersuite, credentialType, amountRequested));
+    return kps.map((kp) => kp.copyBytes());
   }
   async addClientsToConversation(conversationId, keyPackages) {
-    const kps = new ArrayOfByteArray(keyPackages);
-    const dps = await CoreCryptoError.asyncMapErr(this.#ctx.add_clients_to_conversation(conversationId, kps));
-    return dps.as_strings();
+    const kps = keyPackages.map((bytes) => new KeyPackage(bytes));
+    return await CoreCryptoError.asyncMapErr(this.#ctx.add_clients_to_conversation(conversationId, kps));
   }
   async removeClientsFromConversation(conversationId, clientIds) {
-    const ids = clientIds.map((id) => new ClientId(id));
-    return await CoreCryptoError.asyncMapErr(this.#ctx.remove_clients_from_conversation(conversationId, ids));
+    return await CoreCryptoError.asyncMapErr(this.#ctx.remove_clients_from_conversation(conversationId, clientIds));
   }
   async updateKeyingMaterial(conversationId) {
     return await CoreCryptoError.asyncMapErr(this.#ctx.update_keying_material(conversationId));
@@ -3610,6 +3730,12 @@ class CoreCryptoContext2 {
     const config = new CustomConfiguration(keyRotationSpan, wirePolicy);
     return await CoreCryptoError.asyncMapErr(this.#ctx.join_by_external_commit(groupInfo, config, credentialType));
   }
+  async enableHistorySharing(conversationId) {
+    return await CoreCryptoError.asyncMapErr(this.#ctx.enable_history_sharing(conversationId));
+  }
+  async disableHistorySharing(conversationId) {
+    return await CoreCryptoError.asyncMapErr(this.#ctx.disable_history_sharing(conversationId));
+  }
   async exportSecretKey(conversationId, keyLength) {
     return await CoreCryptoError.asyncMapErr(this.#ctx.export_secret_key(conversationId, keyLength));
   }
@@ -3618,7 +3744,7 @@ class CoreCryptoContext2 {
   }
   async getClientIds(conversationId) {
     const ids = await CoreCryptoError.asyncMapErr(this.#ctx.get_client_ids(conversationId));
-    return ids.map((id) => id.as_bytes());
+    return ids;
   }
   async randomBytes(length) {
     return await CoreCryptoError.asyncMapErr(this.#ctx.random_bytes(length));
@@ -3682,26 +3808,19 @@ class CoreCryptoContext2 {
     return await CoreCryptoError.asyncMapErr(this.#ctx.proteus_cryptobox_migrate(storeName));
   }
   async e2eiNewEnrollment(clientId, displayName, handle, expirySec, ciphersuite, team) {
-    const cs = new Ciphersuite2(ciphersuite);
-    const e2ei = await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_new_enrollment(clientId, displayName, handle, team, expirySec, cs));
+    const e2ei = await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_new_enrollment(clientId, displayName, handle, team, expirySec, ciphersuite));
     return new E2eiEnrollment(e2ei);
   }
   async e2eiNewActivationEnrollment(displayName, handle, expirySec, ciphersuite, team) {
-    const cs = new Ciphersuite2(ciphersuite);
-    const e2ei = await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_new_activation_enrollment(displayName, handle, team, expirySec, cs));
+    const e2ei = await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_new_activation_enrollment(displayName, handle, team, expirySec, ciphersuite));
     return new E2eiEnrollment(e2ei);
   }
   async e2eiNewRotateEnrollment(expirySec, ciphersuite, displayName, handle, team) {
-    const cs = new Ciphersuite2(ciphersuite);
-    const e2ei = await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_new_rotate_enrollment(displayName, handle, team, expirySec, cs));
+    const e2ei = await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_new_rotate_enrollment(displayName, handle, team, expirySec, ciphersuite));
     return new E2eiEnrollment(e2ei);
   }
   async e2eiMlsInitOnly(enrollment, certificateChain, nbKeyPackage) {
-    const dps = await this.#ctx.e2ei_mls_init_only(enrollment.inner(), certificateChain, nbKeyPackage);
-    return dps.as_strings();
-  }
-  async e2eiDumpPKIEnv() {
-    return await this.#ctx.e2ei_dump_pki_env();
+    return await this.#ctx.e2ei_mls_init_only(enrollment.inner(), certificateChain, nbKeyPackage);
   }
   async e2eiIsPKIEnvSetup() {
     return await this.#ctx.e2ei_is_pki_env_setup();
@@ -3710,8 +3829,7 @@ class CoreCryptoContext2 {
     return await this.#ctx.e2ei_register_acme_ca(trustAnchorPEM);
   }
   async e2eiRegisterIntermediateCA(certPEM) {
-    const dps = await this.#ctx.e2ei_register_intermediate_ca(certPEM);
-    return dps.as_strings();
+    return await this.#ctx.e2ei_register_intermediate_ca(certPEM);
   }
   async e2eiRegisterCRL(crlDP, crlDER) {
     const reg = await this.#ctx.e2ei_register_crl(crlDP, crlDER);
@@ -3721,12 +3839,10 @@ class CoreCryptoContext2 {
     return await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_rotate(conversationId));
   }
   async saveX509Credential(enrollment, certificateChain) {
-    const dps = await CoreCryptoError.asyncMapErr(this.#ctx.save_x509_credential(enrollment.inner(), certificateChain));
-    return dps.as_strings();
+    return await CoreCryptoError.asyncMapErr(this.#ctx.save_x509_credential(enrollment.inner(), certificateChain));
   }
-  async deleteStaleKeyPackages(cipherSuite) {
-    const cs = new Ciphersuite2(cipherSuite);
-    return await CoreCryptoError.asyncMapErr(this.#ctx.delete_stale_key_packages(cs));
+  async deleteStaleKeyPackages(ciphersuite) {
+    return await CoreCryptoError.asyncMapErr(this.#ctx.delete_stale_key_packages(ciphersuite));
   }
   async e2eiEnrollmentStash(enrollment) {
     return await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_enrollment_stash(enrollment.inner()));
@@ -3740,22 +3856,16 @@ class CoreCryptoContext2 {
     return normalizeEnum(E2eiConversationState2, state);
   }
   async e2eiIsEnabled(ciphersuite) {
-    const cs = new Ciphersuite2(ciphersuite);
-    return await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_is_enabled(cs));
+    return await CoreCryptoError.asyncMapErr(this.#ctx.e2ei_is_enabled(ciphersuite));
   }
   async getDeviceIdentities(conversationId, deviceIds) {
-    const dids = deviceIds.map((did) => new ClientId(did));
-    return await CoreCryptoError.asyncMapErr(this.#ctx.get_device_identities(conversationId, dids));
+    return await CoreCryptoError.asyncMapErr(this.#ctx.get_device_identities(conversationId, deviceIds));
   }
   async getUserIdentities(conversationId, userIds) {
     return await CoreCryptoError.asyncMapErr(this.#ctx.get_user_identities(conversationId, userIds));
   }
-  async getCredentialInUse(groupInfo, credentialType = CredentialType.X509) {
-    const state = await CoreCryptoError.asyncMapErr(this.#ctx.get_credential_in_use(groupInfo, credentialType));
-    return normalizeEnum(E2eiConversationState2, state);
-  }
 }
-// src/core-crypto-ffi.d.ts
+// src/autogenerated/core-crypto-ffi.d.ts
 class BuildMetadata2 {
   timestamp;
   cargoDebug;
@@ -3777,12 +3887,12 @@ class WireIdentity4 {
 
 class X509Identity2 {
   handle;
-  display_name;
+  displayName;
   domain;
   certificate;
-  serial_number;
-  not_before;
-  not_after;
+  serialNumber;
+  notBefore;
+  notAfter;
 }
 // src/CoreCryptoInstance.ts
 class EpochObserverShim {
@@ -3794,6 +3904,19 @@ class EpochObserverShim {
     return this.inner.epochChanged(conversationId, safeBigintToNumber(epoch));
   }
 }
+
+class HistoryObserverShim {
+  inner;
+  constructor(inner) {
+    this.inner = inner;
+  }
+  async historyClientCreated(conversationId, secret) {
+    return this.inner.historyClientCreated(conversationId, secret);
+  }
+}
+function historySecretIntoFfi(secret) {
+  return new HistorySecret(secret.clientId, secret.data);
+}
 function setLogger(logger) {
   CoreCrypto.set_logger(loggerIntoFfi(logger));
 }
@@ -3836,26 +3959,22 @@ class CoreCrypto2 {
     databaseName,
     key,
     clientId,
-    wasmFilePath,
     ciphersuites,
     entropySeed,
     nbKeyPackage
   }) {
-    const cs = new Ciphersuites(Uint16Array.from(ciphersuites.map((cs2) => cs2.valueOf())));
-    const cc = await CoreCryptoError.asyncMapErr(CoreCrypto.async_new(databaseName, key, clientId, cs, entropySeed, nbKeyPackage));
-    return new this(cc);
+    return new this(await CoreCryptoError.asyncMapErr(CoreCrypto.async_new(databaseName, key, clientId, ciphersuites, entropySeed, nbKeyPackage)));
   }
   static async deferredInit({
     databaseName,
     key,
-    entropySeed,
-    wasmFilePath
+    entropySeed
   }) {
     const cc = await CoreCryptoError.asyncMapErr(CoreCrypto.deferred_init(databaseName, key, entropySeed));
     return new this(cc);
   }
   static async historyClient(historySecret) {
-    const cc = await CoreCryptoError.asyncMapErr(CoreCrypto.history_client(historySecret));
+    const cc = await CoreCryptoError.asyncMapErr(CoreCrypto.history_client(historySecretIntoFfi(historySecret)));
     return new this(cc);
   }
   async transaction(callback) {
@@ -3885,12 +4004,6 @@ class CoreCrypto2 {
   constructor(cc) {
     this.#cc = cc;
   }
-  async canClose() {
-    return await this.#cc.can_close();
-  }
-  isLocked() {
-    return false;
-  }
   async close() {
     await CoreCryptoError.asyncMapErr(this.#cc.close());
   }
@@ -3907,21 +4020,23 @@ class CoreCrypto2 {
   }
   async conversationCiphersuite(conversationId) {
     const cs = await CoreCryptoError.asyncMapErr(this.#cc.conversation_ciphersuite(conversationId));
-    return cs.as_u16();
+    return cs;
   }
   async clientPublicKey(ciphersuite, credentialType) {
-    const cs = new Ciphersuite2(ciphersuite);
-    return await CoreCryptoError.asyncMapErr(this.#cc.client_public_key(cs, credentialType));
+    return await CoreCryptoError.asyncMapErr(this.#cc.client_public_key(ciphersuite, credentialType));
   }
   async exportSecretKey(conversationId, keyLength) {
     return await CoreCryptoError.asyncMapErr(this.#cc.export_secret_key(conversationId, keyLength));
   }
+  async isHistorySharingEnabled(conversationId) {
+    return await CoreCryptoError.asyncMapErr(this.#cc.is_history_sharing_enabled(conversationId));
+  }
   async getExternalSender(conversationId) {
     return await CoreCryptoError.asyncMapErr(this.#cc.get_external_sender(conversationId));
   }
   async getClientIds(conversationId) {
     const cids = await CoreCryptoError.asyncMapErr(this.#cc.get_client_ids(conversationId));
-    return cids.map((cid) => cid.as_bytes());
+    return cids;
   }
   async randomBytes(length) {
     return await CoreCryptoError.asyncMapErr(this.#cc.random_bytes(length));
@@ -3954,19 +4069,14 @@ class CoreCrypto2 {
       throw CoreCryptoError.fromStdError(e);
     }
   }
-  async e2eiDumpPKIEnv() {
-    return await this.#cc.e2ei_dump_pki_env();
-  }
   async e2eiIsPKIEnvSetup() {
     return await this.#cc.e2ei_is_pki_env_setup();
   }
   async e2eiIsEnabled(ciphersuite) {
-    const cs = new Ciphersuite2(ciphersuite);
-    return await CoreCryptoError.asyncMapErr(this.#cc.e2ei_is_enabled(cs));
+    return await CoreCryptoError.asyncMapErr(this.#cc.e2ei_is_enabled(ciphersuite));
   }
   async getDeviceIdentities(conversationId, deviceIds) {
-    const dids = deviceIds.map((did) => new ClientId(did));
-    return await CoreCryptoError.asyncMapErr(this.#cc.get_device_identities(conversationId, dids));
+    return await CoreCryptoError.asyncMapErr(this.#cc.get_device_identities(conversationId, deviceIds));
   }
   async getUserIdentities(conversationId, userIds) {
     const map = await CoreCryptoError.asyncMapErr(this.#cc.get_user_identities(conversationId, userIds));
@@ -3978,15 +4088,16 @@ class CoreCrypto2 {
     }
     return mapFixed;
   }
-  async getCredentialInUse(groupInfo, credentialType = CredentialType.X509) {
-    const state = await CoreCryptoError.asyncMapErr(this.#cc.get_credential_in_use(groupInfo, credentialType));
-    return normalizeEnum(E2eiConversationState2, state);
-  }
   async registerEpochObserver(observer) {
     const shim = new EpochObserverShim(observer);
     const ffi = new EpochObserver(shim, shim.epochChanged);
     return await CoreCryptoError.asyncMapErr(this.#cc.register_epoch_observer(ffi));
   }
+  async registerHistoryObserver(observer) {
+    const shim = new HistoryObserverShim(observer);
+    const ffi = new HistoryObserver(shim, shim.historyClientCreated);
+    return await CoreCryptoError.asyncMapErr(this.#cc.register_history_observer(ffi));
+  }
 }
 // src/CoreCrypto.ts
 async function initWasmModule(location = undefined) {
@@ -3999,7 +4110,7 @@ async function initWasmModule(location = undefined) {
     }
   } else {
     const fs = await import("fs/promises");
-    const path = new URL("core-crypto-ffi_bg.wasm", import.meta.url);
+    const path = new URL(`${location}core-crypto-ffi_bg.wasm`, import.meta.url);
     const file = await fs.open(path);
     const buffer = await file.readFile();
     const module = new WebAssembly.Module(buffer);
@@ -4008,21 +4119,28 @@ async function initWasmModule(location = undefined) {
 }
 export {
   version2 as version,
+  updateDatabaseKey,
   setMaxLogLevel,
   setLogger,
   migrateDatabaseKeyTypeToBytes,
   initWasmModule,
+  ciphersuiteFromU16,
+  ciphersuiteDefault,
   buildMetadata,
   X509Identity2 as X509Identity,
   WirePolicy,
   WireIdentity4 as WireIdentity,
   WelcomeBundle,
+  Welcome,
+  SecretKey,
   MlsRatchetTreeType as RatchetTreeType,
   NewAcmeOrder,
   NewAcmeAuthz,
+  MlsTransportData,
   MlsGroupInfoEncryptionType as GroupInfoEncryptionType,
+  GroupInfo,
+  ExternalSenderKey,
   E2eiEnrollment,
-  E2eiDumpedPkiEnv,
   E2eiConversationState2 as E2eiConversationState,
   DeviceStatus,
   DatabaseKey,
@@ -4032,6 +4150,8 @@ export {
   CoreCryptoError,
   CoreCryptoContext2 as CoreCryptoContext,
   CoreCrypto2 as CoreCrypto,
+  ConversationId,
+  ClientId,
   Ciphersuite,
   BuildMetadata2 as BuildMetadata,
   AcmeChallenge