@derec-alliance/nodejs 0.0.1-alpha.6 → 0.0.1-alpha.8

package/derec_library.js

@@ -1,472 +1,1294 @@
 /* @ts-self-types="./derec_library.d.ts" */
 
 /**
- * Creates a serialized `ContactMessage` used to bootstrap pairing.
+ * Fluent builder for [`DeRecProtocolWasm`]. Mirrors the Rust
+ * [`crate::protocol::DeRecProtocolBuilder`] and the dotnet
+ * `DeRecProtocolBuilder` method-for-method so a developer who already
+ * knows one SDK can move between them without reaching for reference
+ * docs.
+ *
+ * Required setters: `withChannelStore`, `withShareStore`,
+ * `withSecretStore`, `withTransport`, `withOwnTransport`. Calling
+ * `build()` without all five throws.
+ *
+ * All optional setters carry the defaults documented on the Rust
+ * builder.
+ */
+class DeRecProtocolBuilder {
+    static __wrap(ptr) {
+        const obj = Object.create(DeRecProtocolBuilder.prototype);
+        obj.__wbg_ptr = ptr;
+        DeRecProtocolBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DeRecProtocolBuilderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_derecprotocolbuilder_free(ptr, 0);
+    }
+    /**
+     * Finalize the configuration. Throws if any of the required
+     * setters was not called.
+     * @returns {DeRecProtocolWasm}
+     */
+    build() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_build(ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DeRecProtocolWasm.__wrap(ret[0]);
+    }
+    /**
+     * `secretId` is a JS `bigint` or `number`. Identifies the single
+     * secret this protocol instance manages; apps that juggle multiple
+     * secrets instantiate one protocol per id.
+     * @param {any} secret_id
+     */
+    constructor(secret_id) {
+        const ret = wasm.derecprotocolbuilder_new(secret_id);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        DeRecProtocolBuilderFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Per-flow auto-accept policy.
+     *
+     * `policy` shape (all fields optional, default `false`):
+     * `{ pairing, prePair, storeShare, verifyShare, discovery, getShare, unpair, updateChannelInfo }`.
+     *
+     * When a field is `true`, `process()` internally accepts the
+     * matching incoming request and emits an `AutoAccepted` event in
+     * place of `ActionRequired`. See the Rust-side
+     * `AutoAcceptPolicy` rustdoc for the per-flow trade-offs.
+     * Default: every field `false`.
+     * @param {any} policy
+     * @returns {DeRecProtocolBuilder}
+     */
+    withAutoAccept(policy) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withAutoAccept(ptr, policy);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DeRecProtocolBuilder.__wrap(ret[0]);
+    }
+    /**
+     * Whether outbound requests stamp `replyTo = ownTransport`.
+     * Default: false.
+     * @param {boolean} enabled
+     * @returns {DeRecProtocolBuilder}
+     */
+    withAutoReplyTo(enabled) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withAutoReplyTo(ptr, enabled);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+    /**
+     * Whether the protocol auto-replies on failed inbound processing.
+     * Default: false.
+     * @param {boolean} enabled
+     * @returns {DeRecProtocolBuilder}
+     */
+    withAutoRespondOnFailure(enabled) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withAutoRespondOnFailure(ptr, enabled);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+    /**
+     * @param {any} store
+     * @returns {DeRecProtocolBuilder}
+     */
+    withChannelStore(store) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withChannelStore(ptr, store);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+    /**
+     * `info` shape: `Record<string, string>`. Default: empty.
+     * @param {any} info
+     * @returns {DeRecProtocolBuilder}
+     */
+    withCommunicationInfo(info) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withCommunicationInfo(ptr, info);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        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` must be `"https"` (the only protocol supported today).
+     * @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]);
+    }
+    /**
+     * Declare the local node's acceptable parameter range for pair
+     * negotiation. `range` is a JS object whose keys mirror the
+     * `ParameterRange` proto (`minShareSize`, `maxShareSize`,
+     * `minTimeBetweenVerifications`, ...). Each field is `i64` —
+     * accept either a number or a `BigInt` on the JS side. Default:
+     * unset (no constraints advertised, every peer range accepted).
+     * @param {any} range
+     * @returns {DeRecProtocolBuilder}
+     */
+    withParameterRange(range) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withParameterRange(ptr, range);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DeRecProtocolBuilder.__wrap(ret[0]);
+    }
+    /**
+     * `id` is a JS `bigint` or `number`. Default: unset.
+     * @param {any} id
+     * @returns {DeRecProtocolBuilder}
+     */
+    withReplicaId(id) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withReplicaId(ptr, id);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DeRecProtocolBuilder.__wrap(ret[0]);
+    }
+    /**
+     * @param {any} store
+     * @returns {DeRecProtocolBuilder}
+     */
+    withSecretStore(store) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withSecretStore(ptr, store);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+    /**
+     * @param {any} store
+     * @returns {DeRecProtocolBuilder}
+     */
+    withShareStore(store) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withShareStore(ptr, store);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+    /**
+     * @param {any} store
+     * @returns {DeRecProtocolBuilder}
+     */
+    withStateStore(store) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withStateStore(ptr, store);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+    /**
+     * Minimum number of shares required to reconstruct the secret.
+     * Default: 3.
+     * @param {number} threshold
+     * @returns {DeRecProtocolBuilder}
+     */
+    withThreshold(threshold) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withThreshold(ptr, threshold);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+    /**
+     * Protocol-wide staleness boundary (seconds). Clamped to at least
+     * 1. Default: 300.
+     * @param {number} timeout_in_secs
+     * @returns {DeRecProtocolBuilder}
+     */
+    withTimeout(timeout_in_secs) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withTimeout(ptr, timeout_in_secs);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+    /**
+     * @param {any} transport
+     * @returns {DeRecProtocolBuilder}
+     */
+    withTransport(transport) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withTransport(ptr, transport);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+    /**
+     * `ack` is `"required"` (default) or `"not_required"`.
+     * @param {string} ack
+     * @returns {DeRecProtocolBuilder}
+     */
+    withUnpairAck(ack) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(ack, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.derecprotocolbuilder_withUnpairAck(ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DeRecProtocolBuilder.__wrap(ret[0]);
+    }
+    /**
+     * @param {any} store
+     * @returns {DeRecProtocolBuilder}
+     */
+    withUserSecretStore(store) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.derecprotocolbuilder_withUserSecretStore(ptr, store);
+        return DeRecProtocolBuilder.__wrap(ret);
+    }
+}
+if (Symbol.dispose) DeRecProtocolBuilder.prototype[Symbol.dispose] = DeRecProtocolBuilder.prototype.free;
+exports.DeRecProtocolBuilder = DeRecProtocolBuilder;
+
+/**
+ * Higher-level DeRec protocol orchestrator for TypeScript/JavaScript consumers.
+ *
+ * Wraps [`DeRecProtocol`](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.
+ *
+ * # Stores
  *
- * # Arguments
+ * 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(...)`.
  *
- * * `channel_id` - Channel identifier associated with the generated pairing material
- * * `transport_uri` - Transport endpoint that the peer should use for subsequent traffic
+ * # Events
  *
- * # Returns
+ * [`process`](DeRecProtocolWasm::process) returns an `Array` of plain JS
+ * objects, each with a `type` discriminant field:
  *
- * A JS object with:
+ * | `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, owner_replica_id }` (same nested shape as `ReplicaSecretReceived.secret`) |
+ * | `NoOp`             | _(none)_                                               |
  *
- * - `wire_bytes`: serialized `ContactMessage` protobuf bytes
- * - `secret_key_material`: serialized `PairingSecretKeyMaterial`
+ * `SecretVersionEntry = { secret_id: bigint, versions: { version: number, description: string }[] }`
+ */
+class DeRecProtocolWasm {
+    static __wrap(ptr) {
+        const obj = Object.create(DeRecProtocolWasm.prototype);
+        obj.__wbg_ptr = ptr;
+        DeRecProtocolWasmFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DeRecProtocolWasmFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_derecprotocolwasm_free(ptr, 0);
+    }
+    /**
+     * Accept a pending action from an `ActionRequired` event.
+     *
+     * # Arguments
+     *
+     * * `action_bytes` — Opaque `Uint8Array` from the `action` field of an `ActionRequired` event.
+     *
+     * # Returns
+     *
+     * An `Array` of event objects (same format as `process()`).
+     * @param {Uint8Array} action_bytes
+     * @returns {Promise<any>}
+     */
+    accept(action_bytes) {
+        const ptr0 = passArray8ToWasm0(action_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.derecprotocolwasm_accept(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Single entry point for all three contact modes (`InlineKeys`,
+     * `HashedKeys`, `NoKeys`).
+     *
+     * * `channel_id` — `null`/`undefined` lets the library mint a
+     *   random id; otherwise `bigint` / `number` is used verbatim.
+     * * `contact_mode` — `0` (InlineKeys), `1` (HashedKeys), `2` (NoKeys).
+     * * `nonce` — `null`/`undefined` lets the library generate a fresh
+     *   random `u64`; otherwise the supplied `bigint`/`number` is used.
+     *   Required for `NoKeys` where callers typically pick a small
+     *   human-typable value.
+     * @param {any} channel_id
+     * @param {number} contact_mode
+     * @param {any} nonce
+     * @returns {Promise<any>}
+     */
+    createContact(channel_id, contact_mode, nonce) {
+        const ret = wasm.derecprotocolwasm_createContact(this.__wbg_ptr, channel_id, contact_mode, nonce);
+        return ret;
+    }
+    /**
+     * Derive the human-readable fingerprint for a paired channel. Both
+     * sides of a replica pair derive the same fingerprint from the
+     * shared key, enabling out-of-band confirmation before the channel
+     * transitions from `Pending` to `Paired`.
+     * @param {any} channel_id
+     * @returns {Promise<string>}
+     */
+    getFingerprint(channel_id) {
+        const ret = wasm.derecprotocolwasm_getFingerprint(this.__wbg_ptr, channel_id);
+        return ret;
+    }
+    /**
+     * Feed any incoming wire bytes to the protocol.
+     *
+     * Returns an `Array` of plain JS event objects (see struct-level docs for shapes).
+     * All five flows (pairing, sharing, verification, discovery, recovery) are
+     * handled through this single entry point.
+     *
+     * # Arguments
+     *
+     * * `message` — Raw wire bytes of an incoming `DeRecMessage`.
+     * @param {Uint8Array} message
+     * @returns {Promise<any>}
+     */
+    process(message) {
+        const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.derecprotocolwasm_process(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Reject a pending action from an `ActionRequired` event.
+     *
+     * # Arguments
+     *
+     * * `action_bytes` — Opaque `Uint8Array` from the `action` field of an `ActionRequired` event.
+     * * `status` — Numeric status code from `StatusEnum` (e.g. 2 for FAIL, 10 for REJECTED).
+     * * `memo` — Human-readable rejection reason.
+     * @param {Uint8Array} action_bytes
+     * @param {number} status
+     * @param {string} memo
+     * @returns {Promise<void>}
+     */
+    reject(action_bytes, status, memo) {
+        const ptr0 = passArray8ToWasm0(action_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(memo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.derecprotocolwasm_reject(this.__wbg_ptr, ptr0, len0, status, ptr1, len1);
+        return ret;
+    }
+    /**
+     * Rebuild this protocol's `secret_id` namespace from a recovered
+     * `Secret`. Mirrors [`crate::protocol::DeRecProtocol::restore`] —
+     * see that method for the full contract.
+     *
+     * `recoveredSecret` is the typed `Secret` object carried by the
+     * `SecretRecovered` event; pass it verbatim.
+     *
+     * Errors surface as structured JS errors with a `code` field:
+     *
+     * | code               | meaning                                                          |
+     * |--------------------|------------------------------------------------------------------|
+     * | `ALREADY_RESTORED` | A user-secret snapshot already exists for this `secret_id`.      |
+     * | `CONFLICT`         | Channels live at canonical helper / replica ids. 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.                             |
+     * @param {any} recovered_secret
+     * @param {number} version
+     * @returns {Promise<any>}
+     */
+    restore(recovered_secret, version) {
+        const ret = wasm.derecprotocolwasm_restore(this.__wbg_ptr, recovered_secret, version);
+        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}
+     */
+    secretId() {
+        const ret = wasm.derecprotocolwasm_secretId(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * Replace this node's local communication info. Does not contact peers —
+     * follow up with a `start(UpdateChannelInfo, ...)` to propagate.
+     * @param {any} info
+     */
+    setCommunicationInfo(info) {
+        const ret = wasm.derecprotocolwasm_setCommunicationInfo(this.__wbg_ptr, info);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Replace this node's local transport endpoint. See
+     * `setCommunicationInfo` for the matching update-propagation flow.
+     * 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]);
+        }
+    }
+    /**
+     * 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 }`)
+     *
+     * # Returns
+     *
+     * An `Array` of `*Started` / `*Failed` events describing the
+     * dispatched requests. Same shape as `process()`.
+     * @param {number} flow_kind
+     * @param {any} params
+     * @returns {Promise<any>}
+     */
+    start(flow_kind, params) {
+        const ret = wasm.derecprotocolwasm_start(this.__wbg_ptr, flow_kind, params);
+        return ret;
+    }
+    /**
+     * Verify a fingerprint against the channel's locally-derived one. On
+     * match, the channel transitions from `Pending` to `Paired`. Returns
+     * `true` when the fingerprint matches and the channel is confirmed,
+     * `false` otherwise.
+     * @param {any} channel_id
+     * @param {string} fingerprint
+     * @returns {Promise<boolean>}
+     */
+    verifyFingerprint(channel_id, fingerprint) {
+        const ptr0 = passStringToWasm0(fingerprint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.derecprotocolwasm_verifyFingerprint(this.__wbg_ptr, channel_id, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) DeRecProtocolWasm.prototype[Symbol.dispose] = DeRecProtocolWasm.prototype.free;
+exports.DeRecProtocolWasm = DeRecProtocolWasm;
+
+/**
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} shared_key
+ * @returns {any}
+ */
+function discovery_request_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.discovery_request_extract(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.discovery_request_extract = discovery_request_extract;
+
+/**
+ * @param {bigint} channel_id
+ * @param {Uint8Array} shared_key
+ * @param {any} reply_to
+ * @returns {any}
+ */
+function discovery_request_produce(channel_id, shared_key, reply_to) {
+    const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.discovery_request_produce(channel_id, ptr0, len0, reply_to);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.discovery_request_produce = discovery_request_produce;
+
+/**
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} shared_key
+ * @returns {any}
+ */
+function discovery_response_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.discovery_response_extract(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.discovery_response_extract = discovery_response_extract;
+
+/**
+ * @param {any} response
+ * @returns {any}
+ */
+function discovery_response_process(response) {
+    const ret = wasm.discovery_response_process(response);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.discovery_response_process = discovery_response_process;
+
+/**
  * @param {bigint} channel_id
- * @param {string} transport_uri
+ * @param {any} secret_list
+ * @param {Uint8Array} shared_key
+ * @returns {any}
+ */
+function discovery_response_produce(channel_id, secret_list, shared_key) {
+    const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.discovery_response_produce(channel_id, secret_list, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.discovery_response_produce = discovery_response_produce;
+
+/**
+ * Overwrite `trace_id` on a primitive-produced envelope and return the
+ * re-encoded bytes. The outer envelope is plaintext, so this does no
+ * crypto work.
+ *
+ * Useful for consumers driving the protocol through primitives directly
+ * (the orchestrator-level `DeRecProtocol` already handles trace_id
+ * end-to-end on its own).
+ * @param {Uint8Array} envelope_bytes
+ * @param {bigint} trace_id
+ * @returns {Uint8Array}
+ */
+function envelope_apply_trace_id(envelope_bytes, trace_id) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.envelope_apply_trace_id(ptr0, len0, trace_id);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+exports.envelope_apply_trace_id = envelope_apply_trace_id;
+
+/**
+ * Read `trace_id` off an inbound envelope without touching the encrypted
+ * inner payload. Returns `0` when the sender didn't set one — the protobuf
+ * default is indistinguishable from an explicit zero.
+ * @param {Uint8Array} envelope_bytes
+ * @returns {bigint}
+ */
+function envelope_read_trace_id(envelope_bytes) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.envelope_read_trace_id(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return BigInt.asUintN(64, ret[0]);
+}
+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
+ */
+function pairing_contact_message_validate(contact_message) {
+    const ret = wasm.pairing_contact_message_validate(contact_message);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+exports.pairing_contact_message_validate = pairing_contact_message_validate;
+
+/**
+ * @param {bigint} channel_id
+ * @param {number} contact_mode
+ * @param {any} transport_protocol
+ * @param {any} nonce
+ * @returns {any}
+ */
+function pairing_request_create_contact(channel_id, contact_mode, transport_protocol, nonce) {
+    const ret = wasm.pairing_request_create_contact(channel_id, contact_mode, transport_protocol, nonce);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+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.
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+function pairing_request_decode_contact(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pairing_request_decode_contact(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+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.
+ * @param {any} contact_message
+ * @returns {Uint8Array}
+ */
+function pairing_request_encode_contact(contact_message) {
+    const ret = wasm.pairing_request_encode_contact(contact_message);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+}
+exports.pairing_request_encode_contact = pairing_request_encode_contact;
+
+/**
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} secret_key
+ * @returns {any}
+ */
+function pairing_request_extract(envelope_bytes, secret_key) {
+    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);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_request_extract = pairing_request_extract;
+
+/**
+ * Initiator-side: decode an inbound plaintext `PrePairRequest` envelope.
+ * @param {Uint8Array} envelope_bytes
+ * @returns {any}
+ */
+function pairing_request_extract_pre_pair(envelope_bytes) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pairing_request_extract_pre_pair(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_request_extract_pre_pair = pairing_request_extract_pre_pair;
+
+/**
+ * @param {number} kind
+ * @param {any} transport_protocol
+ * @param {any} contact_message
+ * @param {any} communication_info
+ * @param {any} parameter_range
+ * @returns {any}
+ */
+function pairing_request_produce(kind, transport_protocol, contact_message, communication_info, parameter_range) {
+    const ret = wasm.pairing_request_produce(kind, transport_protocol, contact_message, communication_info, parameter_range);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_request_produce = pairing_request_produce;
+
+/**
+ * Scanner-side: build the plaintext `PrePairRequest` envelope for a
+ * `HASHED_KEYS` contact.
+ * @param {any} transport_protocol
+ * @param {any} contact_message
+ * @returns {any}
+ */
+function pairing_request_produce_pre_pair(transport_protocol, contact_message) {
+    const ret = wasm.pairing_request_produce_pre_pair(transport_protocol, contact_message);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_request_produce_pre_pair = pairing_request_produce_pre_pair;
+
+/**
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} secret_key
+ * @returns {any}
+ */
+function pairing_response_extract(envelope_bytes, secret_key) {
+    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_response_extract(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_response_extract = pairing_response_extract;
+
+/**
+ * Scanner-side: decode the inbound plaintext `PrePairResponse` envelope.
+ * @param {Uint8Array} envelope_bytes
+ * @returns {any}
+ */
+function pairing_response_extract_pre_pair(envelope_bytes) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pairing_response_extract_pre_pair(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_response_extract_pre_pair = pairing_response_extract_pre_pair;
+
+/**
+ * @param {any} contact_message
+ * @param {any} response
+ * @param {Uint8Array} secret_key
+ * @returns {any}
+ */
+function pairing_response_process(contact_message, response, secret_key) {
+    const ptr0 = passArray8ToWasm0(secret_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pairing_response_process(contact_message, response, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_response_process = pairing_response_process;
+
+/**
+ * Scanner-side: validate the `PrePairResponse` against the contact's
+ * SHA-384 binding hash. Returns the validated keys + nonce on match.
+ * @param {any} contact_message
+ * @param {any} response
+ * @returns {any}
+ */
+function pairing_response_process_pre_pair(contact_message, response) {
+    const ret = wasm.pairing_response_process_pre_pair(contact_message, response);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_response_process_pre_pair = pairing_response_process_pre_pair;
+
+/**
+ * @param {bigint} channel_id
+ * @param {any} request
+ * @param {Uint8Array} secret_key
+ * @param {any} communication_info
+ * @param {any} parameter_range
+ * @returns {any}
+ */
+function pairing_response_produce(channel_id, request, secret_key, communication_info, parameter_range) {
+    const ptr0 = passArray8ToWasm0(secret_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pairing_response_produce(channel_id, request, ptr0, len0, communication_info, parameter_range);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_response_produce = pairing_response_produce;
+
+/**
+ * Contact-creator side: publish the actual public keys back to the scanner.
+ * @param {bigint} channel_id
+ * @param {any} request
+ * @param {Uint8Array} secret_key
+ * @returns {any}
+ */
+function pairing_response_produce_pre_pair(channel_id, request, secret_key) {
+    const ptr0 = passArray8ToWasm0(secret_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pairing_response_produce_pre_pair(channel_id, request, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.pairing_response_produce_pre_pair = pairing_response_produce_pre_pair;
+
+/**
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} shared_key
+ * @returns {any}
+ */
+function recovery_request_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.recovery_request_extract(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.recovery_request_extract = recovery_request_extract;
+
+/**
+ * @param {bigint} channel_id
+ * @param {bigint} secret_id
+ * @param {number} version
+ * @param {Uint8Array} shared_key
+ * @param {any} reply_to
+ * @returns {any}
+ */
+function recovery_request_produce(channel_id, secret_id, version, shared_key, reply_to) {
+    const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.recovery_request_produce(channel_id, secret_id, version, ptr0, len0, reply_to);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.recovery_request_produce = recovery_request_produce;
+
+/**
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} shared_key
+ * @returns {any}
+ */
+function recovery_response_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.recovery_response_extract(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.recovery_response_extract = recovery_response_extract;
+
+/**
+ * @param {bigint} channel_id
+ * @param {any} request
+ * @param {any} stored_share_request
+ * @param {Uint8Array} shared_key
+ * @returns {any}
+ */
+function recovery_response_produce(channel_id, request, stored_share_request, shared_key) {
+    const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.recovery_response_produce(channel_id, request, stored_share_request, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.recovery_response_produce = recovery_response_produce;
+
+/**
+ * @param {bigint} secret_id
+ * @param {number} version
+ * @param {any} responses
+ * @returns {any}
+ */
+function recovery_response_recover(secret_id, version, responses) {
+    const ret = wasm.recovery_response_recover(secret_id, version, responses);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.recovery_response_recover = recovery_response_recover;
+
+/**
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} shared_key
  * @returns {any}
  */
-function create_contact_message(channel_id, transport_uri) {
-    const ptr0 = passStringToWasm0(transport_uri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+function sharing_request_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.create_contact_message(channel_id, ptr0, len0);
+    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.sharing_request_extract(ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.create_contact_message = create_contact_message;
+exports.sharing_request_extract = sharing_request_extract;
 
 /**
- * Generates a recovery request envelope.
- *
- * # Arguments
- *
- * * `channel_id` - Helper channel identifier
- * * `secret_id` - Secret identifier being recovered
- * * `version` - Share version being requested
- * * `shared_key` - 32-byte symmetric key established during pairing
- *
- * # Returns
- *
- * Serialized outer `DeRecMessage` bytes carrying an encrypted inner
- * `GetShareRequestMessage`.
  * @param {bigint} channel_id
- * @param {Uint8Array} secret_id
  * @param {number} version
+ * @param {bigint} secret_id
+ * @param {any} committed_share
+ * @param {any} keep_list
+ * @param {string} description
  * @param {Uint8Array} shared_key
- * @returns {Uint8Array}
+ * @param {any} reply_to
+ * @param {any} replica_id
+ * @returns {any}
  */
-function generate_share_request(channel_id, secret_id, version, shared_key) {
-    const ptr0 = passArray8ToWasm0(secret_id, wasm.__wbindgen_malloc);
+function sharing_request_produce(channel_id, version, secret_id, committed_share, keep_list, description, shared_key, reply_to, replica_id) {
+    const ptr0 = passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.generate_share_request(channel_id, ptr0, len0, version, ptr1, len1);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
+    const ret = wasm.sharing_request_produce(channel_id, version, secret_id, committed_share, keep_list, ptr0, len0, ptr1, len1, reply_to, replica_id);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
-    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v3;
+    return takeFromExternrefTable0(ret[0]);
 }
-exports.generate_share_request = generate_share_request;
+exports.sharing_request_produce = sharing_request_produce;
 
 /**
- * Generates a recovery response envelope.
- *
- * # Arguments
- *
- * * `secret_id` - Secret identifier being recovered
- * * `channel_id` - Helper channel identifier
- * * `stored_share_request_wire_bytes` - Serialized outer `DeRecMessage` bytes
- *   carrying the encrypted inner `StoreShareRequestMessage` previously produced
- *   by the sharing flow for this helper
- * * `request_wire_bytes` - Serialized outer `DeRecMessage` bytes carrying the
- *   encrypted inner `GetShareRequestMessage`
- * * `shared_key` - 32-byte symmetric key established during pairing
- *
- * # Returns
- *
- * Serialized outer `DeRecMessage` bytes carrying an encrypted inner
- * `GetShareResponseMessage`.
- * @param {Uint8Array} secret_id
- * @param {bigint} channel_id
- * @param {Uint8Array} stored_share_request_wire_bytes
- * @param {Uint8Array} request_wire_bytes
+ * @param {any} channels
+ * @param {bigint} secret_id
+ * @param {number} version
+ * @param {Uint8Array} secret_data
+ * @param {number} threshold
+ * @returns {any}
+ */
+function sharing_request_split(channels, secret_id, version, secret_data, threshold) {
+    const ptr0 = passArray8ToWasm0(secret_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sharing_request_split(channels, secret_id, version, ptr0, len0, threshold);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sharing_request_split = sharing_request_split;
+
+/**
+ * @param {Uint8Array} envelope_bytes
  * @param {Uint8Array} shared_key
- * @returns {Uint8Array}
+ * @returns {any}
  */
-function generate_share_response(secret_id, channel_id, stored_share_request_wire_bytes, request_wire_bytes, shared_key) {
-    const ptr0 = passArray8ToWasm0(secret_id, wasm.__wbindgen_malloc);
+function sharing_response_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(stored_share_request_wire_bytes, wasm.__wbindgen_malloc);
+    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArray8ToWasm0(request_wire_bytes, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ptr3 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
-    const len3 = WASM_VECTOR_LEN;
-    const ret = wasm.generate_share_response(ptr0, len0, channel_id, ptr1, len1, ptr2, len2, ptr3, len3);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
+    const ret = wasm.sharing_response_extract(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
-    var v5 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v5;
+    return takeFromExternrefTable0(ret[0]);
 }
-exports.generate_share_response = generate_share_response;
+exports.sharing_response_extract = sharing_response_extract;
 
 /**
- * Generates a verification request envelope.
- *
- * # Arguments
- *
- * * `secret_id` - Secret identifier
- * * `channel_id` - Helper channel identifier
- * * `version` - Share-distribution version being verified
- * * `shared_key` - 32-byte symmetric key established during pairing
- *
- * # Returns
- *
- * A JS object with:
- *
- * - `wire_bytes`: serialized outer `DeRecMessage` bytes carrying an encrypted
- *   inner `VerifyShareRequestMessage`
- * @param {Uint8Array} secret_id
- * @param {bigint} channel_id
  * @param {number} version
+ * @param {any} response
+ */
+function sharing_response_process(version, response) {
+    const ret = wasm.sharing_response_process(version, response);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+exports.sharing_response_process = sharing_response_process;
+
+/**
+ * @param {bigint} channel_id
+ * @param {any} request
+ * @param {Uint8Array} shared_key
+ * @returns {any}
+ */
+function sharing_response_produce(channel_id, request, shared_key) {
+    const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sharing_response_produce(channel_id, request, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.sharing_response_produce = sharing_response_produce;
+
+/**
+ * @param {Uint8Array} envelope_bytes
  * @param {Uint8Array} shared_key
  * @returns {any}
  */
-function generate_verification_request(secret_id, channel_id, version, shared_key) {
-    const ptr0 = passArray8ToWasm0(secret_id, wasm.__wbindgen_malloc);
+function unpairing_request_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.generate_verification_request(ptr0, len0, channel_id, version, ptr1, len1);
+    const ret = wasm.unpairing_request_extract(ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.generate_verification_request = generate_verification_request;
+exports.unpairing_request_extract = unpairing_request_extract;
 
 /**
- * Generates a verification response envelope.
- *
- * # Arguments
- *
- * * `secret_id` - Secret identifier
- * * `channel_id` - Helper channel identifier
- * * `shared_key` - 32-byte symmetric key established during pairing
- * * `share_content` - Share bytes whose possession is being proven
- * * `request_bytes` - Serialized outer `DeRecMessage` bytes carrying encrypted
- *   inner `VerifyShareRequestMessage`
- *
- * # Returns
- *
- * A JS object with:
- *
- * - `wire_bytes`: serialized outer `DeRecMessage` bytes carrying an encrypted
- *   inner `VerifyShareResponseMessage`
- * @param {Uint8Array} secret_id
  * @param {bigint} channel_id
+ * @param {string} memo
  * @param {Uint8Array} shared_key
- * @param {Uint8Array} share_content
- * @param {Uint8Array} request_bytes
+ * @param {any} reply_to
  * @returns {any}
  */
-function generate_verification_response(secret_id, channel_id, shared_key, share_content, request_bytes) {
-    const ptr0 = passArray8ToWasm0(secret_id, wasm.__wbindgen_malloc);
+function unpairing_request_produce(channel_id, memo, shared_key, reply_to) {
+    const ptr0 = passStringToWasm0(memo, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArray8ToWasm0(share_content, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ptr3 = passArray8ToWasm0(request_bytes, wasm.__wbindgen_malloc);
-    const len3 = WASM_VECTOR_LEN;
-    const ret = wasm.generate_verification_response(ptr0, len0, channel_id, ptr1, len1, ptr2, len2, ptr3, len3);
+    const ret = wasm.unpairing_request_produce(channel_id, ptr0, len0, ptr1, len1, reply_to);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.generate_verification_response = generate_verification_response;
+exports.unpairing_request_produce = unpairing_request_produce;
 
 /**
- * Processes a serialized pairing response envelope and derives the responder-side shared key.
- *
- * This is the **responder-side** finalization step: the party that created the pairing request
- * processes the pairing response and derives the same final shared key.
- *
- * # Arguments
- *
- * * `contact_message_bytes` - Plain serialized `ContactMessage` bytes
- * * `pair_response_wire_bytes` - Serialized outer `DeRecMessage` carrying encrypted inner response bytes
- * * `pairing_secret_key_material` - Serialized responder-side `PairingSecretKeyMaterial`
- *
- * # Returns
- *
- * A JS object with:
- *
- * - `pairing_shared_key`: final shared pairing key
- * @param {Uint8Array} contact_message_bytes
- * @param {Uint8Array} pair_response_wire_bytes
- * @param {Uint8Array} pairing_secret_key_material
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} shared_key
  * @returns {any}
  */
-function process_pairing_response_message(contact_message_bytes, pair_response_wire_bytes, pairing_secret_key_material) {
-    const ptr0 = passArray8ToWasm0(contact_message_bytes, wasm.__wbindgen_malloc);
+function unpairing_response_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(pair_response_wire_bytes, wasm.__wbindgen_malloc);
+    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArray8ToWasm0(pairing_secret_key_material, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ret = wasm.process_pairing_response_message(ptr0, len0, ptr1, len1, ptr2, len2);
+    const ret = wasm.unpairing_response_extract(ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.process_pairing_response_message = process_pairing_response_message;
+exports.unpairing_response_extract = unpairing_response_extract;
 
 /**
- * Produces a serialized pairing request envelope from a contact message.
- *
- * This is the **responder-side** step: the party that received the out-of-band
- * contact creates the pairing request.
- *
- * # Arguments
- *
- * * `kind` - Sender role encoded as:
- *   - `0` => `SharerNonRecovery`
- *   - `1` => `SharerRecovery`
- *   - `2` => `Helper`
- * * `transport_uri` - Transport endpoint the responder can use to receive follow-up traffic
- * * `contact_message_bytes` - Plain serialized `ContactMessage` bytes
- *
- * # Returns
- *
- * A JS object with:
- *
- * - `wire_bytes`: serialized outer `DeRecMessage` bytes
- * - `secret_key_material`: serialized responder-side `PairingSecretKeyMaterial`
- * @param {number} kind
- * @param {string} transport_uri
- * @param {Uint8Array} contact_message_bytes
+ * @param {any} response
+ * @returns {any}
+ */
+function unpairing_response_process(response) {
+    const ret = wasm.unpairing_response_process(response);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.unpairing_response_process = unpairing_response_process;
+
+/**
+ * @param {bigint} channel_id
+ * @param {Uint8Array} shared_key
  * @returns {any}
  */
-function produce_pairing_request_message(kind, transport_uri, contact_message_bytes) {
-    const ptr0 = passStringToWasm0(transport_uri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+function unpairing_response_produce(channel_id, shared_key) {
+    const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(contact_message_bytes, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.produce_pairing_request_message(kind, ptr0, len0, ptr1, len1);
+    const ret = wasm.unpairing_response_produce(channel_id, ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.produce_pairing_request_message = produce_pairing_request_message;
+exports.unpairing_response_produce = unpairing_response_produce;
 
 /**
- * Produces a serialized pairing response envelope and derives the initiator-side shared key.
- *
- * This is the **initiator-side** step: the party that originally created the contact
- * processes the incoming pairing request and returns the pairing response.
- *
- * # Arguments
- *
- * * `kind` - Sender role encoded as:
- *   - `0` => `SharerNonRecovery`
- *   - `1` => `SharerRecovery`
- *   - `2` => `Helper`
- * * `pair_request_wire_bytes` - Serialized outer `DeRecMessage` carrying encrypted inner request bytes
- * * `pairing_secret_key_material` - Serialized initiator-side `PairingSecretKeyMaterial`
- *
- * # Returns
- *
- * A JS object with:
- *
- * - `wire_bytes`: serialized outer `DeRecMessage` bytes carrying encrypted inner response bytes
- * - `transport_protocol`: transport information extracted from the pairing request
- * - `pairing_shared_key`: final shared pairing key
- * @param {number} kind
- * @param {Uint8Array} pair_request_wire_bytes
- * @param {Uint8Array} pairing_secret_key_material
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} shared_key
  * @returns {any}
  */
-function produce_pairing_response_message(kind, pair_request_wire_bytes, pairing_secret_key_material) {
-    const ptr0 = passArray8ToWasm0(pair_request_wire_bytes, wasm.__wbindgen_malloc);
+function verification_request_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(pairing_secret_key_material, wasm.__wbindgen_malloc);
+    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.produce_pairing_response_message(kind, ptr0, len0, ptr1, len1);
+    const ret = wasm.verification_request_extract(ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.produce_pairing_response_message = produce_pairing_response_message;
+exports.verification_request_extract = verification_request_extract;
 
 /**
- * Generates verifiable secret shares and returns one serialized outer `DeRecMessage`
- * envelope per helper channel.
- *
- * # JavaScript input shape
- *
- * The `channels` argument must be a JS array of objects like:
- *
- * ```ts
- * [
- *   { channel_id: 1, shared_key: new Uint8Array(32) },
- *   { channel_id: 2, shared_key: new Uint8Array(32) },
- * ]
- * ```
- *
- * Each `shared_key` must be exactly 32 bytes.
- *
- * The `keep_list` argument may be:
- *
- * - `undefined` or `null`, meaning no keep-list is provided
- * - an array of integers, for example:
- *
- * ```ts
- * [1, 2, 3]
- * ```
- *
- * The `description` argument may be:
- *
- * - `undefined` or `null`, meaning no description is provided
- * - a string, for example:
- *
- * ```ts
- * "initial distribution"
- * ```
- *
- * # Returns
- *
- * A JS object of the form:
- *
- * ```ts
- * {
- *   value: {
- *     [channelId: number]: Uint8Array
- *   }
- * }
- * ```
- *
- * where each value is a serialized outer `DeRecMessage` envelope.
- *
- * # Arguments
- *
- * * `secret_id` - Secret identifier embedded into each generated share
- * * `secret_data` - Secret bytes to split and distribute
- * * `channels` - JS array of `{ channel_id, shared_key }` entries
- * * `threshold` - Minimum number of shares required for reconstruction
- * * `version` - Share-distribution version embedded into the generated messages
- * * `keep_list` - Optional JS array of versions helpers should retain
- * * `description` - Optional version description
- * @param {Uint8Array} secret_id
- * @param {Uint8Array} secret_data
- * @param {any} channels
- * @param {number} threshold
+ * @param {bigint} channel_id
+ * @param {bigint} secret_id
  * @param {number} version
- * @param {any} keep_list
- * @param {string | null} [description]
+ * @param {Uint8Array} shared_key
+ * @param {any} reply_to
+ * @returns {any}
+ */
+function verification_request_produce(channel_id, secret_id, version, shared_key, reply_to) {
+    const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.verification_request_produce(channel_id, secret_id, version, ptr0, len0, reply_to);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.verification_request_produce = verification_request_produce;
+
+/**
+ * @param {Uint8Array} envelope_bytes
+ * @param {Uint8Array} shared_key
  * @returns {any}
  */
-function protect_secret(secret_id, secret_data, channels, threshold, version, keep_list, description) {
-    const ptr0 = passArray8ToWasm0(secret_id, wasm.__wbindgen_malloc);
+function verification_response_extract(envelope_bytes, shared_key) {
+    const ptr0 = passArray8ToWasm0(envelope_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(secret_data, wasm.__wbindgen_malloc);
+    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(description) ? 0 : passStringToWasm0(description, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.protect_secret(ptr0, len0, ptr1, len1, channels, threshold, version, keep_list, ptr2, len2);
+    const ret = wasm.verification_response_extract(ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
-exports.protect_secret = protect_secret;
+exports.verification_response_extract = verification_response_extract;
 
 /**
- * Recovers the original secret from helper recovery responses.
- *
- * # Arguments
- *
- * * `responses` - JS array of recovery response inputs. Each entry must contain:
- *   - `response_bytes`: serialized outer `DeRecMessage` response envelope
- *   - `shared_key`: 32-byte symmetric key for decrypting that response
- * * `secret_id` - Secret identifier being recovered
- * * `version` - Secret version being recovered
- *
- * # Returns
- *
- * The reconstructed secret bytes.
- * @param {any} responses
- * @param {Uint8Array} secret_id
- * @param {number} version
- * @returns {Uint8Array}
+ * Verify a `VerifyShareResponseMessage` against the originating
+ * `VerifyShareRequestMessage` and the expected share content.
+ *
+ * `request` must be the request the **owner** previously produced for
+ * this challenge (kept by the caller in a per-`channel_id` pending-
+ * verification map). The primitive rejects any response whose
+ * `(nonce, secret_id, version)` triple doesn't match — that's the
+ * anti-replay gate.
+ * @param {any} request
+ * @param {any} response
+ * @param {Uint8Array} share_content
+ * @returns {boolean}
  */
-function recover_from_share_responses(responses, secret_id, version) {
-    const ptr0 = passArray8ToWasm0(secret_id, wasm.__wbindgen_malloc);
+function verification_response_process(request, response, share_content) {
+    const ptr0 = passArray8ToWasm0(share_content, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.recover_from_share_responses(responses, ptr0, len0, version);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
+    const ret = wasm.verification_response_process(request, response, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
-    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v2;
+    return ret[0] !== 0;
 }
-exports.recover_from_share_responses = recover_from_share_responses;
+exports.verification_response_process = verification_response_process;
 
 /**
- * Verifies a verification response envelope.
- *
- * # Arguments
- *
- * * `secret_id` - Secret identifier
- * * `channel_id` - Helper channel identifier
- * * `shared_key` - 32-byte symmetric key established during pairing
- * * `share_content` - Expected share bytes
- * * `response_bytes` - Serialized outer `DeRecMessage` bytes carrying encrypted
- *   inner `VerifyShareResponseMessage`
- *
- * # Returns
- *
- * `true` if the verification response is valid, otherwise `false`.
- * @param {Uint8Array} secret_id
  * @param {bigint} channel_id
+ * @param {any} request
  * @param {Uint8Array} shared_key
  * @param {Uint8Array} share_content
- * @param {Uint8Array} response_bytes
- * @returns {boolean}
+ * @returns {any}
  */
-function verify_share_response(secret_id, channel_id, shared_key, share_content, response_bytes) {
-    const ptr0 = passArray8ToWasm0(secret_id, wasm.__wbindgen_malloc);
+function verification_response_produce(channel_id, request, shared_key, share_content) {
+    const ptr0 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(shared_key, wasm.__wbindgen_malloc);
+    const ptr1 = passArray8ToWasm0(share_content, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArray8ToWasm0(share_content, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ptr3 = passArray8ToWasm0(response_bytes, wasm.__wbindgen_malloc);
-    const len3 = WASM_VECTOR_LEN;
-    const ret = wasm.verify_share_response(ptr0, len0, channel_id, ptr1, len1, ptr2, len2, ptr3, len3);
+    const ret = wasm.verification_response_produce(channel_id, request, ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ret[0] !== 0;
+    return takeFromExternrefTable0(ret[0]);
 }
-exports.verify_share_response = verify_share_response;
+exports.verification_response_produce = verification_response_produce;
 
 function wasm_start() {
     wasm.wasm_start();
 }
 exports.wasm_start = wasm_start;
-
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_83742b46f01ce22d: function(arg0, arg1) {
+        __wbg_BigInt_9fb73aa817d633b1: function(arg0) {
+            const ret = BigInt(arg0);
+            return ret;
+        },
+        __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_Number_a5a435bd7bbec835: function(arg0) {
+        __wbg_Number_9a4e0ecb0fa16705: function(arg0) {
             const ret = Number(arg0);
             return ret;
         },
@@ -477,68 +1299,76 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_bigint_get_as_i64_447a76b5c6ef7bda: function(arg0, arg1) {
+        __wbg___wbindgen_bigint_get_as_i64_d968e41184ae354f: function(arg0, arg1) {
             const v = arg1;
             const ret = typeof(v) === 'bigint' ? v : undefined;
             getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
-        __wbg___wbindgen_boolean_get_c0f3f60bac5a78d1: function(arg0) {
+        __wbg___wbindgen_boolean_get_fa956cfa2d1bd751: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg___wbindgen_debug_string_5398f5bb970e0daa: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
             const ret = debugString(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_in_41dbb8413020e076: function(arg0, arg1) {
+        __wbg___wbindgen_in_aca499c5de7ff5e5: function(arg0, arg1) {
             const ret = arg0 in arg1;
             return ret;
         },
-        __wbg___wbindgen_is_bigint_e2141d4f045b7eda: function(arg0) {
+        __wbg___wbindgen_is_bigint_2f76dc55065b4273: function(arg0) {
             const ret = typeof(arg0) === 'bigint';
             return ret;
         },
-        __wbg___wbindgen_is_function_3c846841762788c1: function(arg0) {
+        __wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
         },
-        __wbg___wbindgen_is_null_0b605fc6b167c56f: function(arg0) {
+        __wbg___wbindgen_is_null_ea9085d691f535d3: function(arg0) {
             const ret = arg0 === null;
             return ret;
         },
-        __wbg___wbindgen_is_object_781bc9f159099513: function(arg0) {
+        __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
             const val = arg0;
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
-        __wbg___wbindgen_is_string_7ef6b97b02428fae: function(arg0) {
+        __wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
             const ret = typeof(arg0) === 'string';
             return ret;
         },
-        __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(arg0) {
+        __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
-        __wbg___wbindgen_jsval_eq_ee31bfad3e536463: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_eq_e659fcf7b0e32763: function(arg0, arg1) {
             const ret = arg0 === arg1;
             return ret;
         },
-        __wbg___wbindgen_jsval_loose_eq_5bcc3bed3c69e72b: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_loose_eq_db4c3b15f63fc170: function(arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
         },
-        __wbg___wbindgen_number_get_34bb9d9dcfa21373: function(arg0, arg1) {
+        __wbg___wbindgen_lt_f5e407c37b70b8b0: function(arg0, arg1) {
+            const ret = arg0 < arg1;
+            return ret;
+        },
+        __wbg___wbindgen_neg_69ea89900918a95f: function(arg0) {
+            const ret = -arg0;
+            return ret;
+        },
+        __wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'number' ? obj : undefined;
             getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
-        __wbg___wbindgen_string_get_395e606bd0ee4427: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -546,25 +1376,39 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+        __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_call_2d781c1f4d5c0ef8: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = arg0.call(arg1, arg2);
+        __wbg__wbg_cb_unref_fffb441def202758: function(arg0) {
+            arg0._wbg_cb_unref();
+        },
+        __wbg_apply_3ac86a26fdb56c05: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.apply(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_call_e133b57c9155d22c: function() { return handleError(function (arg0, arg1) {
+        __wbg_call_8a2dd23819f8a60a: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
-        __wbg_crypto_48300657fced39f9: function(arg0) {
+        __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
             const ret = arg0.crypto;
             return ret;
         },
-        __wbg_done_08ce71ee07e3bd17: function(arg0) {
+        __wbg_done_89b2b13e91a60321: function(arg0) {
             const ret = arg0.done;
             return ret;
         },
+        __wbg_entries_015dc610cd81ede0: function(arg0) {
+            const ret = Object.entries(arg0);
+            return ret;
+        },
+        __wbg_error_744744ff0c9861e6: function(arg0) {
+            console.error(arg0);
+        },
         __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
             let deferred0_0;
             let deferred0_1;
@@ -576,17 +1420,29 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         },
-        __wbg_getRandomValues_263d0aa5464054ee: function() { return handleError(function (arg0, arg1) {
+        __wbg_from_13e323c65fc8f464: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
             arg0.getRandomValues(arg1);
         }, arguments); },
-        __wbg_getRandomValues_76dfc69825c9c552: function() { return handleError(function (arg0, arg1) {
+        __wbg_getRandomValues_cc7f052a444bb2ce: function() { return handleError(function (arg0, arg1) {
             globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
         }, arguments); },
-        __wbg_get_326e41e095fb2575: function() { return handleError(function (arg0, arg1) {
+        __wbg_get_507a50627bffa49b: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_78f252d074a84d0b: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_c7eb1f358a7654df: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_get_unchecked_329cfe50afab7352: function(arg0, arg1) {
+        __wbg_get_unchecked_6e0ad6d2a41b06f6: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
@@ -594,7 +1450,7 @@ function __wbg_get_imports() {
             const ret = arg0[arg1];
             return ret;
         },
-        __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6: function(arg0) {
+        __wbg_instanceof_ArrayBuffer_4480b9e0068a8adb: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof ArrayBuffer;
@@ -604,7 +1460,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Uint8Array_740438561a5b956d: function(arg0) {
+        __wbg_instanceof_Uint8Array_309b927aaf7a3fc7: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Uint8Array;
@@ -614,27 +1470,27 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_isArray_33b91feb269ff46e: function(arg0) {
+        __wbg_isArray_0677c962b281d01a: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_isSafeInteger_ecd6a7f9c3e053cd: function(arg0) {
+        __wbg_isSafeInteger_04f36e4056f1b851: function(arg0) {
             const ret = Number.isSafeInteger(arg0);
             return ret;
         },
-        __wbg_iterator_d8f549ec8fb061b1: function() {
+        __wbg_iterator_6f722e4a93058b71: function() {
             const ret = Symbol.iterator;
             return ret;
         },
-        __wbg_length_b3416cf66a5452c8: function(arg0) {
+        __wbg_length_1f0964f4a5e2c6d8: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_ea16607d7b61445b: function(arg0) {
+        __wbg_length_370319915dc99107: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_msCrypto_8c6d45a75ef1d3da: function(arg0) {
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
             const ret = arg0.msCrypto;
             return ret;
         },
@@ -642,65 +1498,106 @@ function __wbg_get_imports() {
             const ret = new Error();
             return ret;
         },
-        __wbg_new_49d5571bd3f0c4d4: function() {
+        __wbg_new_32b398fb48b6d94a: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_7796ffc7ed656783: function() {
             const ret = new Map();
             return ret;
         },
-        __wbg_new_5f486cdf45a04d78: function(arg0) {
+        __wbg_new_cd45aabdf6073e84: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
         },
-        __wbg_new_a70fbab9066b301f: function() {
-            const ret = new Array();
+        __wbg_new_da52cf8fe3429cb2: function() {
+            const ret = new Object();
             return ret;
         },
-        __wbg_new_ab79df5bd7c26067: function() {
-            const ret = new Object();
+        __wbg_new_from_slice_77cdfb7977362f3c: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_new_with_length_825018a1616e9e55: function(arg0) {
+        __wbg_new_typed_1824d93f294193e5: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures_____invoke__h6bfc661997de4fd7(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
             const ret = new Uint8Array(arg0 >>> 0);
             return ret;
         },
-        __wbg_next_11b99ee6237339e3: function() { return handleError(function (arg0) {
-            const ret = arg0.next();
-            return ret;
-        }, arguments); },
-        __wbg_next_e01a967809d1aa68: function(arg0) {
+        __wbg_next_6dbf2c0ac8cde20f: function(arg0) {
             const ret = arg0.next;
             return ret;
         },
-        __wbg_node_95beb7570492fd97: function(arg0) {
+        __wbg_next_71f2aa1cb3d1e37e: function() { return handleError(function (arg0) {
+            const ret = arg0.next();
+            return ret;
+        }, arguments); },
+        __wbg_node_84ea875411254db1: function(arg0) {
             const ret = arg0.node;
             return ret;
         },
-        __wbg_now_16f0c993d5dd6c27: function() {
+        __wbg_now_86c0d4ba3fa605b8: function() {
             const ret = Date.now();
             return ret;
         },
-        __wbg_process_b2fea42461d03994: function(arg0) {
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
             const ret = arg0.process;
             return ret;
         },
-        __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
+        __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
-        __wbg_randomFillSync_ca9f178fb14c88cb: function() { return handleError(function (arg0, arg1) {
+        __wbg_push_d2ae3af0c1217ae6: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_queueMicrotask_0ab5b2d2393e99b9: function(arg0) {
+            const ret = arg0.queueMicrotask;
+            return ret;
+        },
+        __wbg_queueMicrotask_6a09b7bc46549209: function(arg0) {
+            queueMicrotask(arg0);
+        },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
             arg0.randomFillSync(arg1);
         }, arguments); },
-        __wbg_require_7a9419e39d796c95: function() { return handleError(function () {
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
             const ret = module.require;
             return ret;
         }, arguments); },
-        __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
-            arg0[arg1 >>> 0] = arg2;
+        __wbg_resolve_2191a4dfe481c25b: function(arg0) {
+            const ret = Promise.resolve(arg0);
+            return ret;
+        },
+        __wbg_set_575dd786d51585f8: function(arg0, arg1, arg2) {
+            const ret = arg0.set(arg1, arg2);
+            return ret;
         },
         __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
-        __wbg_set_bf7251625df30a02: function(arg0, arg1, arg2) {
-            const ret = arg0.set(arg1, arg2);
+        __wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
+        }, arguments); },
+        __wbg_set_8a16b38e4805b298: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
         },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
@@ -709,50 +1606,79 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_static_accessor_GLOBAL_8adb955bd33fac2f: function() {
+        __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_GLOBAL_THIS_ad356e0db91c7913: function() {
+        __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
             const ret = typeof globalThis === 'undefined' ? null : globalThis;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_SELF_f207c857566db248: function() {
+        __wbg_static_accessor_SELF_146583524fe1469b: function() {
             const ret = typeof self === 'undefined' ? null : self;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_WINDOW_bb9f1ba69d61b386: function() {
+        __wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_subarray_a068d24e39478a8a: function(arg0, arg1, arg2) {
+        __wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
             const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
-        __wbg_value_21fc78aab0322612: function(arg0) {
+        __wbg_then_16d107c451e9905d: function(arg0, arg1, arg2) {
+            const ret = arg0.then(arg1, arg2);
+            return ret;
+        },
+        __wbg_then_6ec10ae38b3e92f7: function(arg0, arg1) {
+            const ret = arg0.then(arg1);
+            return ret;
+        },
+        __wbg_toString_34387d7c1df9ca1e: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.toString(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_toString_6a94911348396720: function(arg0, arg1, arg2) {
+            const ret = arg1.toString(arg2);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_value_a5d5488a9589444a: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
-        __wbg_versions_215a3ab1c9d5745a: function(arg0) {
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
             const ret = arg0.versions;
             return ret;
         },
-        __wbindgen_cast_0000000000000001: function(arg0) {
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 287, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h6d974fa9882759cc);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000003: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000004: function(arg0) {
+        __wbindgen_cast_0000000000000006: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;
@@ -773,12 +1699,34 @@ function __wbg_get_imports() {
     };
 }
 
+function wasm_bindgen__convert__closures_____invoke__h6d974fa9882759cc(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h6d974fa9882759cc(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen__convert__closures_____invoke__h6bfc661997de4fd7(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h6bfc661997de4fd7(arg0, arg1, arg2, arg3);
+}
+
+const DeRecProtocolBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_derecprotocolbuilder_free(ptr, 1));
+const DeRecProtocolWasmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_derecprotocolwasm_free(ptr, 1));
+
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
     wasm.__wbindgen_externrefs.set(idx, obj);
     return idx;
 }
 
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -858,8 +1806,7 @@ function getDataViewMemory0() {
 }
 
 function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
+    return decodeText(ptr >>> 0, len);
 }
 
 let cachedUint8ArrayMemory0 = null;
@@ -883,6 +1830,34 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_destroy_closure(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -957,5 +1932,6 @@ let WASM_VECTOR_LEN = 0;
 const wasmPath = `${__dirname}/derec_library_bg.wasm`;
 const wasmBytes = require('fs').readFileSync(wasmPath);
 const wasmModule = new WebAssembly.Module(wasmBytes);
-let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;
 wasm.__wbindgen_start();