@derec-alliance/nodejs 0.0.5 → 0.0.7

package/derec_library.js

@@ -8,11 +8,12 @@
  * docs.
  *
  * Required setters: `withChannelStore`, `withShareStore`,
- * `withSecretStore`, `withTransport`, and either `withOwnTransport` or
- * `withOwnTransports`. Calling `build()` without all five throws.
+ * `withSecretStore`, `withUserSecretStore`, `withStateStore`,
+ * `withTransport`, and `withOwnTransports`. Calling `build()` without all
+ * seven throws.
  *
- * All optional setters carry the defaults documented on the Rust
- * builder.
+ * An optional setter that is never called leaves the Rust builder's default
+ * in force: the value is forwarded only when the application supplied one.
  */
 class DeRecProtocolBuilder {
     static __wrap(ptr) {
@@ -82,7 +83,7 @@ class DeRecProtocolBuilder {
         return DeRecProtocolBuilder.__wrap(ret[0]);
     }
     /**
-     * Whether outbound requests stamp `replyTo = ownTransport`.
+     * Whether outbound requests carry this node's own transports as their reply-to list.
      * Default: false.
      * @param {boolean} enabled
      * @returns {DeRecProtocolBuilder}
@@ -125,49 +126,17 @@ class DeRecProtocolBuilder {
         }
         return DeRecProtocolBuilder.__wrap(ret[0]);
     }
-    /**
-     * Number of recent versions each helper must retain. Default: 3.
-     * @param {number} count
-     * @returns {DeRecProtocolBuilder}
-     */
-    withKeepVersionsCount(count) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.derecprotocolbuilder_withKeepVersionsCount(ptr, count);
-        return DeRecProtocolBuilder.__wrap(ret);
-    }
-    /**
-     * `endpoint` shape: `{ uri: string, protocol: string }`.
-     * `protocol` is `"https"` or `"grpc"` (case-insensitive).
-     *
-     * @deprecated Use `withOwnTransports`, which takes the whole preference
-     * list — `withOwnTransports([endpoint])` is the direct replacement.
-     * Removed at 0.0.5.
-     * @param {any} endpoint
-     * @returns {DeRecProtocolBuilder}
-     */
-    withOwnTransport(endpoint) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.derecprotocolbuilder_withOwnTransport(ptr, endpoint);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return DeRecProtocolBuilder.__wrap(ret[0]);
-    }
     /**
      * Every transport endpoint this application serves, in preference
      * order. `transports` is an array of `{ uri: string, protocol: string
      * }` objects, `protocol` being `"https"` or `"grpc"`
-     * (case-insensitive), same shape as [`Self::with_own_transport`].
+     * (case-insensitive).
      *
      * The order is the application's own preference and decides which of
      * a peer's offered endpoints is used. Every listed transport must
      * actually be served, because delivery is push-only — listing an
      * endpoint this application does not serve makes pairing succeed and
      * replies vanish.
-     *
-     * Supersedes [`Self::with_own_transport`] for applications serving
-     * more than one transport; the single-endpoint setter remains fully
-     * supported.
      * @param {any[]} transports
      * @returns {DeRecProtocolBuilder}
      */
@@ -244,7 +213,7 @@ class DeRecProtocolBuilder {
     }
     /**
      * Minimum number of shares required to reconstruct the secret.
-     * Default: 3.
+     * Default: [`crate::protocol::DEFAULT_THRESHOLD`].
      * @param {number} threshold
      * @returns {DeRecProtocolBuilder}
      */
@@ -292,7 +261,8 @@ class DeRecProtocolBuilder {
         return DeRecProtocolBuilder.__wrap(ret);
     }
     /**
-     * `ack` is `"required"` (default) or `"not_required"`.
+     * `ack` is exactly `"required"` (default) or `"not_required"`, naming
+     * [`UnpairAck::Required`] and [`UnpairAck::NotRequired`].
      * @param {string} ack
      * @returns {DeRecProtocolBuilder}
      */
@@ -308,19 +278,7 @@ class DeRecProtocolBuilder {
     }
     /**
      * Accept plaintext transport endpoints — `http://` and `grpc://`.
-     * **Development only.** Default `false`. See `withUnsafeHttp` for the
-     * conflict rule when both are set.
-     * @param {boolean} allow
-     * @returns {DeRecProtocolBuilder}
-     */
-    withUnsafeConnection(allow) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.derecprotocolbuilder_withUnsafeConnection(ptr, allow);
-        return DeRecProtocolBuilder.__wrap(ret);
-    }
-    /**
-     * Accept plaintext `http://` transport endpoints. **Development only.**
-     * Default `false`.
+     * **Development only.** Default `false`.
      *
      * With it `false`, plaintext is accepted only for an endpoint this
      * device configured for *itself* that names loopback (`localhost`,
@@ -328,15 +286,12 @@ class DeRecProtocolBuilder {
      * With it `true`, plaintext is accepted for any host on any path,
      * including endpoints a peer supplies. That is what makes the LAN case
      * work (a phone against a laptop), and why the name is blunt.
-     *
-     * Superseded by `withUnsafeConnection`; still honored, and wins on
-     * conflict. Removed at 0.0.5.
      * @param {boolean} allow
      * @returns {DeRecProtocolBuilder}
      */
-    withUnsafeHttp(allow) {
+    withUnsafeConnection(allow) {
         const ptr = this.__destroy_into_raw();
-        const ret = wasm.derecprotocolbuilder_withUnsafeHttp(ptr, allow);
+        const ret = wasm.derecprotocolbuilder_withUnsafeConnection(ptr, allow);
         return DeRecProtocolBuilder.__wrap(ret);
     }
     /**
@@ -356,31 +311,46 @@ exports.DeRecProtocolBuilder = DeRecProtocolBuilder;
  * Higher-level DeRec protocol orchestrator for TypeScript/JavaScript consumers.
  *
  * Wraps [`crate::protocol::DeRecProtocol`] with JS-side store
- * and transport adapters so that a TypeScript application can drive all five
- * protocol flows without routing raw bytes manually.
+ * and transport adapters so that a TypeScript application can drive every
+ * protocol flow without routing raw bytes manually. Built with
+ * [`DeRecProtocolBuilderWasm`] (`DeRecProtocolBuilder` in JS).
  *
  * # Stores
  *
- * Pass four JS objects that implement the interfaces documented on each
- * parameter.  All store methods must return `Promise`s — synchronous
- * implementations can wrap their result with `Promise.resolve(...)`.
+ * The five stores and the transport are JS objects implementing the
+ * `ChannelStore`, `ShareStore`, `SecretStore`, `UserSecretStore`,
+ * `StateStore` and `Transport` interfaces in `index.d.ts`. All their methods
+ * must return `Promise`s — synchronous implementations can wrap their result
+ * with `Promise.resolve(...)`.
  *
- * # Events
+ * # Concurrency
+ *
+ * Every method that touches protocol state is `async` and runs under one
+ * lock per instance, so overlapping calls on the same instance — a
+ * `tick` timer firing while `process` handles an inbound message — queue
+ * and run one at a time, in the order they were made. Distinct instances
+ * do not share the lock: two instances bound to the same `secret_id` and
+ * the same stores must still be serialized by the caller.
  *
- * [`process`](DeRecProtocolWasm::process) returns an `Array` of plain JS
- * objects, each with a `type` discriminant field:
+ * A store or transport callback must not await a call on the instance
+ * that invoked it: that call queues behind the one waiting on the
+ * callback, and neither settles. Calling `free()` while a call is in
+ * flight throws.
  *
- * | `type`             | Additional fields                                      |
- * |--------------------|--------------------------------------------------------|
- * | `PairingCompleted`  | `channel_id: string`, `pairing_channel_id: string`, `kind: number` |
- * | `ShareStored`      | `channel_id: string`, `version: number`                |
- * | `ShareConfirmed`   | `channel_id: string`, `version: number`                |
- * | `ShareVerified`    | `channel_id: string`, `version: number`                |
- * | `SecretsDiscovered`| `channel_id: string`, `secrets: SecretVersionEntry[]`  |
- * | `SecretRecovered`  | `secret: { helpers, secrets, replicas }` (same nested shape as `ReplicaSecretReceived.secret`) |
- * | `NoOp`             | _(none)_                                               |
+ * Methods take `&self` for this reason: wasm-bindgen holds the borrow of
+ * the instance for an async call's whole lifetime, so under `&mut self` an
+ * overlapping call fails that borrow outside its promise and never
+ * settles.
  *
- * `SecretVersionEntry = { secret_id: bigint, versions: { version: number, description: string }[] }`
+ * # Events
+ *
+ * [`process`](DeRecProtocolWasm::process), [`start`](DeRecProtocolWasm::start),
+ * [`accept`](DeRecProtocolWasm::accept), [`tick`](DeRecProtocolWasm::tick)
+ * and [`restore`](DeRecProtocolWasm::restore) return an `Array` of plain JS
+ * objects, one per [`crate::protocol::DeRecEvent`], each tagged by a `type`
+ * field naming the variant. Every `u64` identifier (`channel_id`,
+ * `secret_id`, `replica_id`, `trace_id`) is a decimal string. The full set of
+ * shapes is the `DeRecEvent` union in `index.d.ts`.
  */
 class DeRecProtocolWasm {
     static __wrap(ptr) {
@@ -503,7 +473,10 @@ class DeRecProtocolWasm {
      * # Returns
      *
      * An `Array` of removed channel ids as decimal strings.
-     * @param {number} older_than_secs
+     *
+     * `older_than_secs` is a `u64`: a `bigint`, a non-negative safe-integer
+     * `number`, or a decimal string.
+     * @param {any} older_than_secs
      * @returns {Promise<any>}
      */
     removeExpiredChannels(older_than_secs) {
@@ -516,17 +489,22 @@ class DeRecProtocolWasm {
      * see that method for the full contract.
      *
      * `recoveredSecret` is the typed `Secret` object carried by the
-     * `SecretRecovered` event; pass it verbatim.
+     * `SecretRecovered` event; pass it verbatim. A helper or member whose
+     * `transports` is empty, `null` or absent gets no channel; it is
+     * reported as a `PeerNotRestored` event in the returned array and the
+     * rest of the roster is restored.
      *
-     * Errors surface as structured JS errors with a `code` field:
+     * Errors surface as a `DeRecError` (`category`, `code`, `message`):
      *
      * | code               | meaning                                                          |
      * |--------------------|------------------------------------------------------------------|
-     * | `ALREADY_RESTORED` | A user-secret snapshot already exists for this `secret_id`.      |
-     * | `CONFLICT`         | Channels live at canonical helper / replica ids. The error       |
+     * | `already_restored` | A user-secret snapshot already exists for this `secret_id`.      |
+     * | `restore_conflict` | Channels live at ids restore is about to write. The error        |
      * |                    | carries `channel_ids: string[]` listing the collisions.          |
-     * | `INVARIANT`        | The recovered `Secret` is internally inconsistent.               |
-     * | `STORAGE`          | A store I/O call failed mid-restore.                             |
+     * | `invariant`        | The recovered `Secret` is internally inconsistent.               |
+     * | `invalid_recovered_secret` | `recoveredSecret` is malformed — e.g. a missing or       |
+     * |                    | non-decimal `channel_id` / `replica_id`.                         |
+     * | `store_error`      | A store call failed mid-restore; `category` names the store.     |
      * @param {any} recovered_secret
      * @param {number} version
      * @returns {Promise<any>}
@@ -536,24 +514,6 @@ class DeRecProtocolWasm {
         return ret;
     }
     /**
-     * Generate an out-of-band contact message (QR code payload, deep link, …).
-     *
-     * Returns a plain JS `ContactMessage` object. The `channel_id` field identifies
-     * the pairing session and will match the `channel_id` in the eventual
-     * `PairingCompleted` event — read it directly from the returned object.
-     *
-     * The caller is responsible for serializing the contact for out-of-band
-     * delivery (QR code, deep link, etc.). The peer passes the deserialized object
-     * to [`start`](Self::start) with `FlowKind::Pairing`.
-     *
-     * # Arguments
-     *
-     * * `channel_id` — Optional `BigInt` channel identifier. Pass `null` or
-     *   `undefined` to have the library generate a random one.
-     * * `contact_mode` — `0` for `InlineKeys` (keys embedded directly), `1`
-     *   for `HashedKeys` (contact carries only a SHA-384 binding hash; the
-     *   scanner fetches keys via a `PrePair` round-trip). `HashedKeys`
-     *   requires the protocol's `own_transport` to be ephemeral.
      * The secret identifier this protocol instance is bound to.
      * @returns {bigint}
      */
@@ -565,49 +525,18 @@ class DeRecProtocolWasm {
      * Replace this node's local communication info. Does not contact peers —
      * follow up with a `start(UpdateChannelInfo, ...)` to propagate.
      * @param {any} info
+     * @returns {Promise<void>}
      */
     setCommunicationInfo(info) {
         const ret = wasm.derecprotocolwasm_setCommunicationInfo(this.__wbg_ptr, info);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * Replace this node's endpoint for one protocol, leaving the others
-     * alone. A node serves at most one endpoint per protocol, so the
-     * `(uri, protocol)` pair identifies the entry it replaces; an entry for
-     * a protocol not yet served is appended, and a replaced one keeps its
-     * position in the preference order.
-     *
-     * @deprecated Use `setOwnTransports`, which takes the whole preference
-     * list and is the only way to change which protocols this node serves,
-     * or their order. Removed at 0.0.5.
-     *
-     * See `setCommunicationInfo` for the matching update-propagation
-     * flow, and `setOwnTransports` to keep more than one endpoint.
-     * IMPORTANT: keep the old endpoint operational during the changeover —
-     * see the Rust docs on `set_own_transport` for the discipline.
-     * @param {string} uri
-     * @param {string} protocol
-     */
-    setOwnTransport(uri, protocol) {
-        const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(protocol, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.derecprotocolwasm_setOwnTransport(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+        return ret;
     }
     /**
      * Replace every endpoint this node advertises, in preference order.
      *
      * `transports` is an array of `{ uri: string, protocol: string }`
-     * objects, same shape as `withOwnTransports`. The runtime counterpart
-     * to that builder setter, and the way to change the whole set:
-     * `setOwnTransport` replaces only the entry for the protocol its URI
-     * names. A node serves at most one endpoint per protocol, so this list
+     * objects, same shape as `withOwnTransports`, and is its runtime
+     * counterpart. A node serves at most one endpoint per protocol, so this list
      * is a preference order over distinct protocols and two entries of the
      * same protocol are rejected.
      *
@@ -616,26 +545,24 @@ class DeRecProtocolWasm {
      * operational during the changeover — see the Rust docs on
      * `set_own_transports` for the discipline.
      * @param {any[]} transports
+     * @returns {Promise<void>}
      */
     setOwnTransports(transports) {
         const ptr0 = passArrayJsValueToWasm0(transports, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.derecprotocolwasm_setOwnTransports(this.__wbg_ptr, ptr0, len0);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+        return ret;
     }
     /**
      * Unified entry point for initiating any protocol flow.
      *
      * # Arguments
      *
-     * * `flow_kind` — Flow discriminant:
-     *   - `0` = Pairing (params: `{ kind: number, contact: ContactMessage, name?: string }`)
-     *   - `1` = Discovery (params: `{ target: BigInt | BigInt[] | null }`)
-     *   - `2` = ProtectSecret (params: `{ secrets: UserSecret[], description?: string }`)
-     *   - `3` = VerifyShares (params: `{ version: number, target: BigInt | BigInt[] | null }`)
-     *   - `4` = RecoverSecret (params: `{ secretId: Uint8Array, version: number }`)
+     * * `flow_kind` — `FlowKind` discriminant: `0` Pairing, `1` Discovery,
+     *   `2` ProtectSecret, `3` VerifyShares, `4` RecoverSecret, `5` Unpair,
+     *   `6` UpdateChannelInfo, `7` ReplicaDiscovery, `8` UnpairReplica.
+     * * `params` — the flow's parameters, declared per kind in `index.d.ts`
+     *   as `PairingParams`, `DiscoveryParams`, … `UnpairReplicaParams`.
      *
      * # Returns
      *
@@ -811,18 +738,44 @@ function envelope_read_trace_id(envelope_bytes) {
 exports.envelope_read_trace_id = envelope_read_trace_id;
 
 /**
- * Structurally validate a JS-side [`ContactMessage`]. Throws on any
- * mode/field inconsistency (unknown `contact_mode`, mode/field mismatch,
- * wrong binding-hash length).
- * @param {any} contact_message
+ * A fresh replica identity. See [`crate::generate_replica_id`]: the caller
+ * persists it once per device and passes the same value on every protocol
+ * init. Never `0`.
+ * @returns {bigint}
  */
-function pairing_contact_message_validate(contact_message) {
-    const ret = wasm.pairing_contact_message_validate(contact_message);
-    if (ret[1]) {
-        throw takeFromExternrefTable0(ret[0]);
+function generate_replica_id() {
+    const ret = wasm.generate_replica_id();
+    return BigInt.asUintN(64, ret);
+}
+exports.generate_replica_id = generate_replica_id;
+
+/**
+ * The human-readable fingerprint of a pairing's shared key. Both ends derive
+ * the same value; comparing it out of band confirms the pairing.
+ * @param {Uint8Array} shared_key
+ * @returns {string}
+ */
+function pairing_fingerprint(shared_key) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pairing_fingerprint(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
-exports.pairing_contact_message_validate = pairing_contact_message_validate;
+exports.pairing_fingerprint = pairing_fingerprint;
 
 /**
  * @param {bigint} channel_id
@@ -841,9 +794,8 @@ function pairing_request_create_contact(channel_id, contact_mode, transport_prot
 exports.pairing_request_create_contact = pairing_request_create_contact;
 
 /**
- * Decodes a proto-encoded [`ContactMessage`]. Structurally validates the
- * decoded value before returning it to application code so consumers can
- * trust the mode/field invariants documented on the wire format.
+ * Decodes proto `ContactMessage` wire bytes. See
+ * [`crate::primitives::pairing::request::decode_contact`].
  * @param {Uint8Array} bytes
  * @returns {any}
  */
@@ -859,10 +811,8 @@ function pairing_request_decode_contact(bytes) {
 exports.pairing_request_decode_contact = pairing_request_decode_contact;
 
 /**
- * Encodes a [`ContactMessage`] to proto wire bytes. Structurally validates
- * the input first so a locally-constructed contact that violates the
- * mode/field invariant is rejected at the boundary rather than silently
- * serialized.
+ * Encodes a [`ContactMessage`] to proto wire bytes. See
+ * [`crate::primitives::pairing::request::encode_contact`].
  * @param {any} contact_message
  * @returns {Uint8Array}
  */
@@ -880,14 +830,15 @@ exports.pairing_request_encode_contact = pairing_request_encode_contact;
 /**
  * @param {Uint8Array} envelope_bytes
  * @param {Uint8Array} secret_key
+ * @param {any} parameter_range
  * @returns {any}
  */
-function pairing_request_extract(envelope_bytes, secret_key) {
+function pairing_request_extract(envelope_bytes, secret_key, parameter_range) {
     const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(secret_key, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.pairing_request_extract(ptr0, len0, ptr1, len1);
+    const ret = wasm.pairing_request_extract(ptr0, len0, ptr1, len1, parameter_range);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -982,12 +933,13 @@ exports.pairing_response_extract_pre_pair = pairing_response_extract_pre_pair;
  * @param {any} contact_message
  * @param {any} response
  * @param {Uint8Array} secret_key
+ * @param {any} parameter_range
  * @returns {any}
  */
-function pairing_response_process(contact_message, response, secret_key) {
+function pairing_response_process(contact_message, response, secret_key, parameter_range) {
     const ptr0 = passArray8ToWasm0(secret_key, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.pairing_response_process(contact_message, response, ptr0, len0);
+    const ret = wasm.pairing_response_process(contact_message, response, ptr0, len0, parameter_range);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1011,6 +963,24 @@ function pairing_response_process_pre_pair(contact_message, response) {
 }
 exports.pairing_response_process_pre_pair = pairing_response_process_pre_pair;
 
+/**
+ * Scanner side of a `NO_KEYS` pairing: accept the contact creator's public
+ * keys. There is no binding hash to check them against, so the channel this
+ * leads to MUST stay unusable until both sides confirm `pairing_fingerprint`
+ * out of band.
+ * @param {any} contact_message
+ * @param {any} response
+ * @returns {any}
+ */
+function pairing_response_process_pre_pair_no_keys(contact_message, response) {
+    const ret = wasm.pairing_response_process_pre_pair_no_keys(contact_message, response);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_response_process_pre_pair_no_keys = pairing_response_process_pre_pair_no_keys;
+
 /**
  * @param {bigint} channel_id
  * @param {any} request
@@ -1049,6 +1019,41 @@ function pairing_response_produce_pre_pair(channel_id, request, secret_key) {
 }
 exports.pairing_response_produce_pre_pair = pairing_response_produce_pre_pair;
 
+/**
+ * Contact-creator side of a `NO_KEYS` pairing: generate key material and
+ * answer the `PrePairRequest` with its public half.
+ *
+ * The caller MUST first match the request's `nonce` against the contact it
+ * issued, and MUST keep the resulting channel unusable until both sides
+ * confirm `pairing_fingerprint` out of band.
+ * @param {bigint} channel_id
+ * @param {any} request
+ * @returns {any}
+ */
+function pairing_response_produce_pre_pair_no_keys(channel_id, request) {
+    const ret = wasm.pairing_response_produce_pre_pair_no_keys(channel_id, request);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_response_produce_pre_pair_no_keys = pairing_response_produce_pre_pair_no_keys;
+
+/**
+ * The DeRec protocol version this build speaks — the `protocolVersionMajor`
+ * / `protocolVersionMinor` it writes into every envelope it produces —
+ * as `{ major, minor }`.
+ * @returns {any}
+ */
+function protocol_version() {
+    const ret = wasm.protocol_version();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.protocol_version = protocol_version;
+
 /**
  * @param {Uint8Array} envelope_bytes
  * @param {Uint8Array} shared_key
@@ -1574,9 +1579,6 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_error_dd408a7b3cb542dd: function(arg0) {
-            console.error(arg0);
-        },
         __wbg_from_74f3d90e0ff11240: function(arg0) {
             const ret = Array.from(arg0);
             return ret;
@@ -1811,7 +1813,7 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 383, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 404, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h379e0770a020d351);
             return ret;
         },