@automerge/sedimentree 0.8.2 → 0.9.0

package/dist/wasm_bindgen/web/sedimentree_wasm.js

@@ -48,7 +48,7 @@ export class BlobMeta {
      * @param {Uint8Array} blob
      */
     constructor(blob) {
-        const ptr0 = passArray8ToWasm0(blob, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(blob, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.blobmeta_new(ptr0, len0);
         this.__wbg_ptr = ret >>> 0;
@@ -66,6 +66,142 @@ export class BlobMeta {
 }
 if (Symbol.dispose) BlobMeta.prototype[Symbol.dispose] = BlobMeta.prototype.free;
 
+/**
+ * A user-supplied opaque identifier for a loose commit.
+ *
+ * Unlike [`Digest`](crate::digest::WasmDigest), which is a content hash
+ * computed by the system, `CommitId` is provided by the caller at construction
+ * time. This is the identity used for DAG traversal, fragment boundaries,
+ * and sync.
+ */
+export class CommitId {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CommitId.prototype);
+        obj.__wbg_ptr = ptr;
+        CommitIdFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CommitIdFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_commitid_free(ptr, 0);
+    }
+    /**
+     * Upcasts; to the JS-import type for [`WasmCommitId`].
+     * @returns {CommitId}
+     */
+    __wasm_refgen_toWasmCommitId() {
+        const ret = wasm.commitid___wasm_refgen_toWasmCommitId(this.__wbg_ptr);
+        return CommitId.__wrap(ret);
+    }
+    /**
+     * Creates a new commit identifier from its Base58 string representation.
+     *
+     * # Errors
+     *
+     * Returns an error if the string cannot be decoded or is not 32 bytes.
+     * @param {string} s
+     * @returns {CommitId}
+     */
+    static fromBase58(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.commitid_fromBase58(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CommitId.__wrap(ret[0]);
+    }
+    /**
+     * Creates a new commit identifier from its byte representation.
+     *
+     * # Errors
+     *
+     * Returns an error if the byte slice is not exactly 32 bytes.
+     * @param {Uint8Array} bytes
+     * @returns {CommitId}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.commitid_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CommitId.__wrap(ret[0]);
+    }
+    /**
+     * Creates a new commit identifier from its hexadecimal string representation.
+     *
+     * # Errors
+     *
+     * Returns an error if the string is not valid hex or not 32 bytes.
+     * @param {string} s
+     * @returns {CommitId}
+     */
+    static fromHexString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.commitid_fromHexString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CommitId.__wrap(ret[0]);
+    }
+    /**
+     * Creates a new commit identifier from its byte representation.
+     *
+     * # Errors
+     *
+     * Returns an error if the byte slice is not exactly 32 bytes.
+     * @param {Uint8Array} bytes
+     */
+    constructor(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.commitid_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        CommitIdFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns the byte representation of the commit identifier.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.commitid_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_export6(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Returns the hexadecimal string representation.
+     * @returns {string}
+     */
+    toHexString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.commitid_toHexString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_export6(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) CommitId.prototype[Symbol.dispose] = CommitId.prototype.free;
+
 /**
  * A commit stored with its associated blob.
  */
@@ -234,7 +370,7 @@ export class Digest {
      * @returns {Digest}
      */
     static fromBase58(s) {
-        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export3, wasm.__wbindgen_export5);
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.digest_fromBase58(ptr0, len0);
         if (ret[2]) {
@@ -252,7 +388,7 @@ export class Digest {
      * @returns {Digest}
      */
     static fromBytes(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.digest_fromBytes(ptr0, len0);
         if (ret[2]) {
@@ -270,7 +406,7 @@ export class Digest {
      * @returns {Digest}
      */
     static fromHexString(s) {
-        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export3, wasm.__wbindgen_export5);
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.digest_fromHexString(ptr0, len0);
         if (ret[2]) {
@@ -287,7 +423,7 @@ export class Digest {
      * @param {Uint8Array} bytes
      */
     constructor(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.digest_new(ptr0, len0);
         if (ret[2]) {
@@ -364,8 +500,8 @@ export class Fragment {
         return BlobMeta.__wrap(ret);
     }
     /**
-     * Get the boundary digests of the fragment.
-     * @returns {Digest[]}
+     * Get the boundary commit identifiers of the fragment.
+     * @returns {CommitId[]}
      */
     get boundary() {
         const ret = wasm.fragment_boundary(this.__wbg_ptr);
@@ -374,29 +510,29 @@ export class Fragment {
         return v1;
     }
     /**
-     * Get the head digest of the fragment.
-     * @returns {Digest}
+     * Get the head commit identifier of the fragment.
+     * @returns {CommitId}
      */
     get head() {
         const ret = wasm.fragment_head(this.__wbg_ptr);
-        return Digest.__wrap(ret);
+        return CommitId.__wrap(ret);
     }
     /**
      * Create a new fragment from the given sedimentree ID, head, boundary, checkpoints, and blob metadata.
      * @param {SedimentreeId} sedimentree_id
-     * @param {Digest} head
-     * @param {Digest[]} boundary
-     * @param {Digest[]} checkpoints
+     * @param {CommitId} head
+     * @param {CommitId[]} boundary
+     * @param {CommitId[]} checkpoints
      * @param {BlobMeta} blob_meta
      */
     constructor(sedimentree_id, head, boundary, checkpoints, blob_meta) {
         _assertClass(sedimentree_id, SedimentreeId);
         var ptr0 = sedimentree_id.__destroy_into_raw();
-        _assertClass(head, Digest);
+        _assertClass(head, CommitId);
         var ptr1 = head.__destroy_into_raw();
-        const ptr2 = passArrayJsValueToWasm0(boundary, wasm.__wbindgen_export3);
+        const ptr2 = passArrayJsValueToWasm0(boundary, wasm.__wbindgen_export);
         const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passArrayJsValueToWasm0(checkpoints, wasm.__wbindgen_export3);
+        const ptr3 = passArrayJsValueToWasm0(checkpoints, wasm.__wbindgen_export);
         const len3 = WASM_VECTOR_LEN;
         _assertClass(blob_meta, BlobMeta);
         var ptr4 = blob_meta.__destroy_into_raw();
@@ -536,7 +672,15 @@ export class LooseCommit {
         return BlobMeta.__wrap(ret);
     }
     /**
-     * Get the digest of the commit.
+     * Get the commit's head identifier.
+     * @returns {CommitId}
+     */
+    get commitId() {
+        const ret = wasm.loosecommit_commitId(this.__wbg_ptr);
+        return CommitId.__wrap(ret);
+    }
+    /**
+     * Get the digest of the commit (content hash).
      * @returns {Digest}
      */
     get digest() {
@@ -544,25 +688,28 @@ export class LooseCommit {
         return Digest.__wrap(ret);
     }
     /**
-     * Create a new `LooseCommit` from the given sedimentree ID, parents, and blob metadata.
+     * Create a new `LooseCommit` from the given sedimentree ID, head, parents, and blob metadata.
      * @param {SedimentreeId} sedimentree_id
-     * @param {Digest[]} parents
+     * @param {CommitId} head
+     * @param {CommitId[]} parents
      * @param {BlobMeta} blob_meta
      */
-    constructor(sedimentree_id, parents, blob_meta) {
+    constructor(sedimentree_id, head, parents, blob_meta) {
         _assertClass(sedimentree_id, SedimentreeId);
         var ptr0 = sedimentree_id.__destroy_into_raw();
-        const ptr1 = passArrayJsValueToWasm0(parents, wasm.__wbindgen_export3);
-        const len1 = WASM_VECTOR_LEN;
+        _assertClass(head, CommitId);
+        var ptr1 = head.__destroy_into_raw();
+        const ptr2 = passArrayJsValueToWasm0(parents, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
         _assertClass(blob_meta, BlobMeta);
-        const ret = wasm.loosecommit_new(ptr0, ptr1, len1, blob_meta.__wbg_ptr);
+        const ret = wasm.loosecommit_new(ptr0, ptr1, ptr2, len2, blob_meta.__wbg_ptr);
         this.__wbg_ptr = ret >>> 0;
         LooseCommitFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Get the parent digests of the commit.
-     * @returns {Digest[]}
+     * Get the parent commit identifiers.
+     * @returns {CommitId[]}
      */
     get parents() {
         const ret = wasm.loosecommit_parents(this.__wbg_ptr);
@@ -610,27 +757,27 @@ export class MemoryStorage {
         return ret;
     }
     /**
-     * Delete a commit by digest.
+     * Delete a single commit by its ID.
      * @param {SedimentreeId} sedimentree_id
-     * @param {Digest} digest
+     * @param {CommitId} commit_id
      * @returns {Promise<any>}
      */
-    deleteCommit(sedimentree_id, digest) {
+    deleteCommit(sedimentree_id, commit_id) {
         _assertClass(sedimentree_id, SedimentreeId);
-        _assertClass(digest, Digest);
-        const ret = wasm.memorystorage_deleteCommit(this.__wbg_ptr, sedimentree_id.__wbg_ptr, digest.__wbg_ptr);
+        _assertClass(commit_id, CommitId);
+        const ret = wasm.memorystorage_deleteCommit(this.__wbg_ptr, sedimentree_id.__wbg_ptr, commit_id.__wbg_ptr);
         return ret;
     }
     /**
-     * Delete a fragment by digest.
+     * Delete a fragment by its identifier.
      * @param {SedimentreeId} sedimentree_id
-     * @param {Digest} digest
+     * @param {CommitId} fragment_head
      * @returns {Promise<any>}
      */
-    deleteFragment(sedimentree_id, digest) {
+    deleteFragment(sedimentree_id, fragment_head) {
         _assertClass(sedimentree_id, SedimentreeId);
-        _assertClass(digest, Digest);
-        const ret = wasm.memorystorage_deleteFragment(this.__wbg_ptr, sedimentree_id.__wbg_ptr, digest.__wbg_ptr);
+        _assertClass(fragment_head, CommitId);
+        const ret = wasm.memorystorage_deleteFragment(this.__wbg_ptr, sedimentree_id.__wbg_ptr, fragment_head.__wbg_ptr);
         return ret;
     }
     /**
@@ -644,23 +791,23 @@ export class MemoryStorage {
         return ret;
     }
     /**
-     * List all commit digests for a sedimentree.
+     * List all commit IDs for a sedimentree.
      * @param {SedimentreeId} sedimentree_id
      * @returns {Promise<any>}
      */
-    listCommitDigests(sedimentree_id) {
+    listCommitIds(sedimentree_id) {
         _assertClass(sedimentree_id, SedimentreeId);
-        const ret = wasm.memorystorage_listCommitDigests(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        const ret = wasm.memorystorage_listCommitIds(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
         return ret;
     }
     /**
-     * List all fragment digests for a sedimentree.
+     * List all fragment IDs for a sedimentree.
      * @param {SedimentreeId} sedimentree_id
      * @returns {Promise<any>}
      */
-    listFragmentDigests(sedimentree_id) {
+    listFragmentIds(sedimentree_id) {
         _assertClass(sedimentree_id, SedimentreeId);
-        const ret = wasm.memorystorage_listFragmentDigests(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
+        const ret = wasm.memorystorage_listFragmentIds(this.__wbg_ptr, sedimentree_id.__wbg_ptr);
         return ret;
     }
     /**
@@ -692,27 +839,27 @@ export class MemoryStorage {
         return ret;
     }
     /**
-     * Load a commit by digest, returning `CommitWithBlob` or null.
+     * Load a single commit by its ID, returning `CommitWithBlob` or null.
      * @param {SedimentreeId} sedimentree_id
-     * @param {Digest} digest
+     * @param {CommitId} commit_id
      * @returns {Promise<any>}
      */
-    loadCommit(sedimentree_id, digest) {
+    loadCommit(sedimentree_id, commit_id) {
         _assertClass(sedimentree_id, SedimentreeId);
-        _assertClass(digest, Digest);
-        const ret = wasm.memorystorage_loadCommit(this.__wbg_ptr, sedimentree_id.__wbg_ptr, digest.__wbg_ptr);
+        _assertClass(commit_id, CommitId);
+        const ret = wasm.memorystorage_loadCommit(this.__wbg_ptr, sedimentree_id.__wbg_ptr, commit_id.__wbg_ptr);
         return ret;
     }
     /**
-     * Load a fragment by digest, returning `FragmentWithBlob` or null.
+     * Load a fragment by its identifier, returning `FragmentWithBlob` or null.
      * @param {SedimentreeId} sedimentree_id
-     * @param {Digest} digest
+     * @param {CommitId} fragment_head
      * @returns {Promise<any>}
      */
-    loadFragment(sedimentree_id, digest) {
+    loadFragment(sedimentree_id, fragment_head) {
         _assertClass(sedimentree_id, SedimentreeId);
-        _assertClass(digest, Digest);
-        const ret = wasm.memorystorage_loadFragment(this.__wbg_ptr, sedimentree_id.__wbg_ptr, digest.__wbg_ptr);
+        _assertClass(fragment_head, CommitId);
+        const ret = wasm.memorystorage_loadFragment(this.__wbg_ptr, sedimentree_id.__wbg_ptr, fragment_head.__wbg_ptr);
         return ret;
     }
     /**
@@ -724,34 +871,55 @@ export class MemoryStorage {
         MemoryStorageFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Save commits and fragments in a single batch.
+     * @param {SedimentreeId} sedimentree_id
+     * @param {Array<any>} commits
+     * @param {Array<any>} fragments
+     * @returns {Promise<any>}
+     */
+    saveBatchAll(sedimentree_id, commits, fragments) {
+        _assertClass(sedimentree_id, SedimentreeId);
+        const ret = wasm.memorystorage_saveBatchAll(this.__wbg_ptr, sedimentree_id.__wbg_ptr, commits, fragments);
+        return ret;
+    }
     /**
      * Save a commit with its blob.
+     *
+     * The `commit_id` parameter must match the `head()` embedded in
+     * the signed commit payload. Returns an error if they differ.
+     *
+     * # Errors
+     *
+     * Returns a JS error if:
+     * - The signed payload cannot be decoded
+     * - The `commit_id` does not match the embedded `head()`
      * @param {SedimentreeId} sedimentree_id
-     * @param {Digest} _digest
+     * @param {CommitId} commit_id
      * @param {SignedLooseCommit} signed_commit
      * @param {Uint8Array} blob
      * @returns {Promise<any>}
      */
-    saveCommit(sedimentree_id, _digest, signed_commit, blob) {
+    saveCommit(sedimentree_id, commit_id, signed_commit, blob) {
         _assertClass(sedimentree_id, SedimentreeId);
-        _assertClass(_digest, Digest);
+        _assertClass(commit_id, CommitId);
         _assertClass(signed_commit, SignedLooseCommit);
-        const ret = wasm.memorystorage_saveCommit(this.__wbg_ptr, sedimentree_id.__wbg_ptr, _digest.__wbg_ptr, signed_commit.__wbg_ptr, blob);
+        const ret = wasm.memorystorage_saveCommit(this.__wbg_ptr, sedimentree_id.__wbg_ptr, commit_id.__wbg_ptr, signed_commit.__wbg_ptr, blob);
         return ret;
     }
     /**
      * Save a fragment with its blob.
      * @param {SedimentreeId} sedimentree_id
-     * @param {Digest} _digest
+     * @param {CommitId} _fragment_head
      * @param {SignedFragment} signed_fragment
      * @param {Uint8Array} blob
      * @returns {Promise<any>}
      */
-    saveFragment(sedimentree_id, _digest, signed_fragment, blob) {
+    saveFragment(sedimentree_id, _fragment_head, signed_fragment, blob) {
         _assertClass(sedimentree_id, SedimentreeId);
-        _assertClass(_digest, Digest);
+        _assertClass(_fragment_head, CommitId);
         _assertClass(signed_fragment, SignedFragment);
-        const ret = wasm.memorystorage_saveFragment(this.__wbg_ptr, sedimentree_id.__wbg_ptr, _digest.__wbg_ptr, signed_fragment.__wbg_ptr, blob);
+        const ret = wasm.memorystorage_saveFragment(this.__wbg_ptr, sedimentree_id.__wbg_ptr, _fragment_head.__wbg_ptr, signed_fragment.__wbg_ptr, blob);
         return ret;
     }
     /**
@@ -802,9 +970,9 @@ export class Sedimentree {
      * @param {LooseCommit[]} commits
      */
     constructor(fragments, commits) {
-        const ptr0 = passArrayJsValueToWasm0(fragments, wasm.__wbindgen_export3);
+        const ptr0 = passArrayJsValueToWasm0(fragments, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayJsValueToWasm0(commits, wasm.__wbindgen_export3);
+        const ptr1 = passArrayJsValueToWasm0(commits, wasm.__wbindgen_export);
         const len1 = WASM_VECTOR_LEN;
         const ret = wasm.sedimentree_new(ptr0, len0, ptr1, len1);
         this.__wbg_ptr = ret >>> 0;
@@ -853,7 +1021,7 @@ export class SedimentreeId {
      * @returns {SedimentreeId}
      */
     static fromBytes(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export3);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.sedimentreeid_fromBytes(ptr0, len0);
         if (ret[2]) {
@@ -930,6 +1098,12 @@ export class SignedFragment {
         SignedFragmentFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof SignedFragment)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -1001,6 +1175,12 @@ export class SignedLooseCommit {
         SignedLooseCommitFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof SignedLooseCommit)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -1064,24 +1244,31 @@ if (Symbol.dispose) SignedLooseCommit.prototype[Symbol.dispose] = SignedLooseCom
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wasm_refgen_toWasmDigest_d0fbca90d003e5b2: function(arg0) {
-            const ret = arg0.__wasm_refgen_toWasmDigest();
-            _assertClass(ret, Digest);
+        __wbg___wasm_refgen_toWasmCommitId_65b818e358f27de6: function(arg0) {
+            const ret = arg0.__wasm_refgen_toWasmCommitId();
+            _assertClass(ret, CommitId);
             var ptr1 = ret.__destroy_into_raw();
             return ptr1;
         },
-        __wbg___wasm_refgen_toWasmFragment_32ab33a0a1cf967b: function(arg0) {
+        __wbg___wasm_refgen_toWasmFragment_38ddb9958dbdc455: function(arg0) {
             const ret = arg0.__wasm_refgen_toWasmFragment();
             _assertClass(ret, Fragment);
             var ptr1 = ret.__destroy_into_raw();
             return ptr1;
         },
-        __wbg___wasm_refgen_toWasmLooseCommit_6deda612421ca7e6: function(arg0) {
+        __wbg___wasm_refgen_toWasmLooseCommit_876edb05490f6350: function(arg0) {
             const ret = arg0.__wasm_refgen_toWasmLooseCommit();
             _assertClass(ret, LooseCommit);
             var ptr1 = ret.__destroy_into_raw();
             return ptr1;
         },
+        __wbg___wbindgen_debug_string_5398f5bb970e0daa: function(arg0, arg1) {
+            const ret = debugString(arg1);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_is_function_3c846841762788c1: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
@@ -1106,26 +1293,42 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_commitwithblob_new: function(arg0) {
-            const ret = CommitWithBlob.__wrap(arg0);
+        __wbg_commitid_new: function(arg0) {
+            const ret = CommitId.__wrap(arg0);
             return ret;
         },
-        __wbg_digest_new: function(arg0) {
-            const ret = Digest.__wrap(arg0);
+        __wbg_commitwithblob_new: function(arg0) {
+            const ret = CommitWithBlob.__wrap(arg0);
             return ret;
         },
         __wbg_fragmentwithblob_new: function(arg0) {
             const ret = FragmentWithBlob.__wrap(arg0);
             return ret;
         },
+        __wbg_get_3ef1eba1850ade27: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_unchecked_329cfe50afab7352: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
         __wbg_isSafeInteger_ecd6a7f9c3e053cd: function(arg0) {
             const ret = Number.isSafeInteger(arg0);
             return ret;
         },
+        __wbg_length_b3416cf66a5452c8: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_length_ea16607d7b61445b: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_new_5f486cdf45a04d78: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
         __wbg_new_a70fbab9066b301f: function() {
             const ret = new Array();
             return ret;
@@ -1145,7 +1348,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_533_66(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_563_75(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1181,6 +1384,14 @@ function __wbg_get_imports() {
         __wbg_set_name_7ef37fe858379aaf: function(arg0, arg1, arg2) {
             arg0.name = getStringFromWasm0(arg1, arg2);
         },
+        __wbg_signedfragment_unwrap: function(arg0) {
+            const ret = SignedFragment.__unwrap(arg0);
+            return ret;
+        },
+        __wbg_signedloosecommit_unwrap: function(arg0) {
+            const ret = SignedLooseCommit.__unwrap(arg0);
+            return ret;
+        },
         __wbg_static_accessor_GLOBAL_8adb955bd33fac2f: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1202,8 +1413,8 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 64, function: Function { arguments: [Externref], shim_idx: 126, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_366, __wasm_bindgen_func_elem_533);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 73, function: Function { arguments: [Externref], shim_idx: 136, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_400, __wasm_bindgen_func_elem_563);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -1232,15 +1443,15 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_533(arg0, arg1, arg2) {
-    const ret = wasm.__wasm_bindgen_func_elem_533(arg0, arg1, arg2);
+function __wasm_bindgen_func_elem_563(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_563(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function __wasm_bindgen_func_elem_533_66(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_533_66(arg0, arg1, arg2, arg3);
+function __wasm_bindgen_func_elem_563_75(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_563_75(arg0, arg1, arg2, arg3);
 }
 
 const MemoryStorageFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -1249,6 +1460,9 @@ const MemoryStorageFinalization = (typeof FinalizationRegistry === 'undefined')
 const BlobMetaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_blobmeta_free(ptr >>> 0, 1));
+const CommitIdFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_commitid_free(ptr >>> 0, 1));
 const CommitWithBlobFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_commitwithblob_free(ptr >>> 0, 1));
@@ -1287,7 +1501,7 @@ const SignedLooseCommitFinalization = (typeof FinalizationRegistry === 'undefine
     : new FinalizationRegistry(ptr => wasm.__wbg_signedloosecommit_free(ptr >>> 0, 1));
 
 function addToExternrefTable0(obj) {
-    const idx = wasm.__wbindgen_export2();
+    const idx = wasm.__wbindgen_export4();
     wasm.__wbindgen_externrefs.set(idx, obj);
     return idx;
 }
@@ -1302,6 +1516,71 @@ const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(state => state.dtor(state.a, state.b));
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
@@ -1344,7 +1623,7 @@ function handleError(f, args) {
         return f.apply(this, args);
     } catch (e) {
         const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_export(idx);
+        wasm.__wbindgen_export3(idx);
     }
 }
 
@@ -1436,7 +1715,7 @@ function passStringToWasm0(arg, malloc, realloc) {
 
 function takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__wbindgen_export4(idx);
+    wasm.__wbindgen_export5(idx);
     return value;
 }