@fireproof/core 0.5.16 → 0.5.18

package/dist/src/fireproof.js

@@ -2318,7 +2318,7 @@ const coerce$1 = o => {
  * @param {Code} code
  * @param {Uint8Array} digest
  */
-const create$6 = (code, digest) => {
+const create$8 = (code, digest) => {
   const size = digest.byteLength;
   const sizeOffset = encodingLength$1(code);
   const digestOffset = sizeOffset + encodingLength$1(size);
@@ -3078,7 +3078,7 @@ let CID$1 = class CID {
     switch (this.version) {
       case 0: {
         const { code, digest } = this.multihash;
-        const multihash = create$6(code, digest);
+        const multihash = create$8(code, digest);
         return /** @type {CID<Data, Format, Alg, 1>} */ (
           CID.createV1(this.code, multihash)
         )
@@ -3552,9 +3552,9 @@ class Hasher {
     if (input instanceof Uint8Array) {
       const result = this.encode(input);
       return result instanceof Uint8Array
-        ? create$6(this.code, result)
+        ? create$8(this.code, result)
         /* c8 ignore next 1 */
-        : result.then(digest => create$6(this.code, digest))
+        : result.then(digest => create$8(this.code, digest))
     } else {
       throw Error('Unknown type, must be binary type')
       /* c8 ignore next 1 */
@@ -3821,7 +3821,7 @@ function createUnsafe ({ bytes, cid, value: maybeValue, codec }) {
  * @param {API.MultihashHasher<Alg>} options.hasher
  * @returns {Promise<API.BlockView<T, Code, Alg, V>>}
  */
-async function create$5 ({ bytes, cid, hasher, codec }) {
+async function create$7 ({ bytes, cid, hasher, codec }) {
   if (!bytes) throw new Error('Missing required argument "bytes"')
   if (!hasher) throw new Error('Missing required argument "hasher"')
   const value = codec.decode(bytes);
@@ -3978,8 +3978,8 @@ class Token {
 }
 
 const useBuffer = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === 'function';
-const textDecoder = new TextDecoder();
-const textEncoder = new TextEncoder();
+const textDecoder$1 = new TextDecoder();
+const textEncoder$1 = new TextEncoder();
 function isBuffer$1(buf) {
   return useBuffer && globalThis.Buffer.isBuffer(buf);
 }
@@ -3992,12 +3992,12 @@ function asU8A(buf) {
 const toString = useBuffer ? (bytes, start, end) => {
   return end - start > 64 ? globalThis.Buffer.from(bytes.subarray(start, end)).toString('utf8') : utf8Slice(bytes, start, end);
 } : (bytes, start, end) => {
-  return end - start > 64 ? textDecoder.decode(bytes.subarray(start, end)) : utf8Slice(bytes, start, end);
+  return end - start > 64 ? textDecoder$1.decode(bytes.subarray(start, end)) : utf8Slice(bytes, start, end);
 };
 const fromString = useBuffer ? string => {
   return string.length > 64 ? globalThis.Buffer.from(string) : utf8ToBytes(string);
 } : string => {
-  return string.length > 64 ? textEncoder.encode(string) : utf8ToBytes(string);
+  return string.length > 64 ? textEncoder$1.encode(string) : utf8ToBytes(string);
 };
 const fromArray$1 = arr => {
   return Uint8Array.from(arr);
@@ -5715,12 +5715,13 @@ async function findEventsToSync (blocks, head) {
   // console.time(callTag + '.findCommonAncestorWithSortedEvents')
   const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head);
   // console.timeEnd(callTag + '.findCommonAncestorWithSortedEvents')
-  // console.log('sorted', !!ancestor, sorted.length)
+  // console.log('sorted', !!ancestor, sorted)
   // console.time(callTag + '.contains')
 
   const toSync = ancestor ? await asyncFilter(sorted, async uks => !(await contains(events, ancestor, uks.cid))) : sorted;
   // console.timeEnd(callTag + '.contains')
-  // console.log('optimize sorted', !!ancestor, sorted.length - toSync.length)
+  const sortDifference = sorted.length - toSync.length;
+  if (sortDifference / sorted.length > 0.6) console.log('optimize sorted', !!ancestor, sortDifference);
 
   return { cids: events, events: toSync }
 }
@@ -6756,7 +6757,7 @@ class IPLDLeaf extends IPLDNode {
     return true;
   }
 }
-const create$4 = async function* (obj) {
+const create$6 = async function* (obj) {
   let {LeafClass, LeafEntryClass, BranchClass, BranchEntryClass, list, chunker, compare, ...opts} = obj;
   list = list.map(value => new LeafEntryClass(value, opts));
   opts.compare = compare;
@@ -6788,35 +6789,36 @@ const create$4 = async function* (obj) {
 };
 
 class MapEntry extends Entry {
-  async identity() {
+  async identity () {
     const encoded = await this.codec.encode(await this.encodeNode());
     const hash = await this.hasher.encode(encoded);
-    return readUInt32LE$1(hash);
+    return readUInt32LE$1(hash)
   }
 }
 class MapLeafEntry extends MapEntry {
-  constructor(node, opts) {
+  constructor (node, opts) {
     super(node, opts);
     this.value = node.value;
   }
-  encodeNode() {
+
+  encodeNode () {
     return [
       this.key,
       this.value
-    ];
+    ]
   }
 }
 class MapBranchEntry extends MapEntry {
-  constructor(node, opts) {
-    if (!node.address)
-      throw new Error('Cannot create MapBranchEntry without address');
+  constructor (node, opts) {
+    if (!node.address) { throw new Error('Cannot create MapBranchEntry without address') }
     super(node, opts);
   }
-  async encodeNode() {
+
+  async encodeNode () {
     return [
       this.key,
       await this.address
-    ];
+    ]
   }
 }
 const getValue = async (node, key) => {
@@ -6827,7 +6829,7 @@ const getValue = async (node, key) => {
   return {
     result: entry.value,
     cids
-  };
+  }
 };
 const getManyValues = async (node, keys) => {
   const {
@@ -6837,34 +6839,38 @@ const getManyValues = async (node, keys) => {
   return {
     result: entries.map(entry => entry.value),
     cids
-  };
+  }
 };
 class MapLeaf extends IPLDLeaf {
-  get(key) {
-    return getValue(this, key);
+  get (key) {
+    return getValue(this, key)
   }
-  getMany(keys) {
-    return getManyValues(this, keys);
+
+  getMany (keys) {
+    return getManyValues(this, keys)
   }
-  bulk(bulk, opts = {}, isRoot = true) {
+
+  bulk (bulk, opts = {}, isRoot = true) {
     return super.bulk(bulk, {
       ...classes$1,
       ...opts
-    }, isRoot);
+    }, isRoot)
   }
 }
 class MapBranch extends IPLDBranch {
-  get(key) {
-    return getValue(this, key);
+  get (key) {
+    return getValue(this, key)
   }
-  getMany(keys) {
-    return getManyValues(this, keys);
+
+  getMany (keys) {
+    return getManyValues(this, keys)
   }
-  bulk(bulk, opts = {}, isRoot = true) {
+
+  bulk (bulk, opts = {}, isRoot = true) {
     return super.bulk(bulk, {
       ...classes$1,
       ...opts
-    }, isRoot);
+    }, isRoot)
   }
 }
 const classes$1 = {
@@ -6879,9 +6885,8 @@ const createGetNode$1 = (get, cache, chunker, codec, hasher, compare, opts) => {
   const BranchClass = opts.BranchClass || MapBranch;
   const BranchEntryClass = opts.BranchEntryClass || MapBranchEntry;
   const getNode = async cid => {
-    if (cache.has(cid))
-      return cache.get(cid);
-    return get(cid).then(block => decoder(block));
+    if (cache.has(cid)) { return cache.get(cid) }
+    return get(cid).then(block => decoder(block))
   };
   const decoder = makeDecoder({
     chunker,
@@ -6895,11 +6900,10 @@ const createGetNode$1 = (get, cache, chunker, codec, hasher, compare, opts) => {
     BranchEntryClass,
     BranchClass
   });
-  return getNode;
+  return getNode
 };
-const create$3 = ({get, cache, chunker, list, codec, hasher, sorted, compare, ...opts}) => {
-  if (!sorted)
-    list = list.sort(({key: a}, {key: b}) => compare(a, b));
+const create$5 = ({ get, cache, chunker, list, codec, hasher, sorted, compare, ...opts }) => {
+  if (!sorted) { list = list.sort(({ key: a }, { key: b }) => compare(a, b)); }
   const getNode = createGetNode$1(get, cache, chunker, codec, hasher, compare, opts);
   const _opts = {
     list,
@@ -6915,19 +6919,19 @@ const create$3 = ({get, cache, chunker, list, codec, hasher, sorted, compare, ..
     BranchClass: opts.BranchClass || MapBranch,
     BranchEntryClass: opts.BranchEntryClass || MapBranchEntry
   };
-  return create$4(_opts);
+  return create$6(_opts)
 };
-const load$2 = ({cid, get, cache, chunker, codec, hasher, compare, ...opts}) => {
+const load$4 = ({ cid, get, cache, chunker, codec, hasher, compare, ...opts }) => {
   const getNode = createGetNode$1(get, cache, chunker, codec, hasher, compare, opts);
-  return getNode(cid);
+  return getNode(cid)
 };
-function makeDecoder({chunker, cache, getNode, codec, hasher, compare, LeafEntryClass, LeafClass, BranchEntryClass, BranchClass}) {
+function makeDecoder ({ chunker, cache, getNode, codec, hasher, compare, LeafEntryClass, LeafClass, BranchEntryClass, BranchClass }) {
   const entryOpts = {
     codec,
     hasher
   };
   return block => {
-    const {value} = block;
+    const { value } = block;
     const opts = {
       chunker,
       cache,
@@ -6954,7 +6958,7 @@ function makeDecoder({chunker, cache, getNode, codec, hasher, compare, LeafEntry
       }, entryOpts));
       CLS = BranchClass;
     } else {
-      throw new Error('Unknown block data, does not match schema');
+      throw new Error('Unknown block data, does not match schema')
     }
     const entryList = new EntryList({
       entries,
@@ -6965,8 +6969,8 @@ function makeDecoder({chunker, cache, getNode, codec, hasher, compare, LeafEntry
       ...opts
     });
     cache.set(node);
-    return node;
-  };
+    return node
+  }
 }
 
 const nocache = {
@@ -7010,7 +7014,7 @@ const parse = (source, base) => CID$1.parse(source, base);
  *
  */
 
-const Kinds = {
+const Kinds$1 = {
   Null: /**
          * @param {any} obj
          * @returns {boolean}
@@ -7038,7 +7042,7 @@ const Kinds = {
   Link: /**
          * @param {any} obj
          * @returns {boolean}
-         */ (/** @type {any} */ obj) => !Kinds.Null(obj) && typeof obj === 'object' && obj.asCID === obj,
+         */ (/** @type {any} */ obj) => !Kinds$1.Null(obj) && typeof obj === 'object' && obj.asCID === obj,
   List: /**
          * @param {any} obj
          * @returns {boolean}
@@ -7046,31 +7050,31 @@ const Kinds = {
   Map: /**
         * @param {any} obj
         * @returns {boolean}
-        */ (/** @type {any} */ obj) => !Kinds.Null(obj) && typeof obj === 'object' && obj.asCID !== obj && !Kinds.List(obj) && !Kinds.Bytes(obj)
+        */ (/** @type {any} */ obj) => !Kinds$1.Null(obj) && typeof obj === 'object' && obj.asCID !== obj && !Kinds$1.List(obj) && !Kinds$1.Bytes(obj)
 };
 /** @type {{ [k in string]: (obj:any)=>boolean}} */
-const Types = {
-  Int: Kinds.Int,
+const Types$1 = {
+  Int: Kinds$1.Int,
   'CarHeader > version': /**
                           * @param {any} obj
                           * @returns {boolean}
-                          */ (/** @type {any} */ obj) => Types.Int(obj),
-  'CarHeader > roots (anon) > valueType (anon)': Kinds.Link,
+                          */ (/** @type {any} */ obj) => Types$1.Int(obj),
+  'CarHeader > roots (anon) > valueType (anon)': Kinds$1.Link,
   'CarHeader > roots (anon)': /**
                                * @param {any} obj
                                * @returns {boolean}
-                               */ (/** @type {any} */ obj) => Kinds.List(obj) && Array.prototype.every.call(obj, Types['CarHeader > roots (anon) > valueType (anon)']),
+                               */ (/** @type {any} */ obj) => Kinds$1.List(obj) && Array.prototype.every.call(obj, Types$1['CarHeader > roots (anon) > valueType (anon)']),
   'CarHeader > roots': /**
                         * @param {any} obj
                         * @returns {boolean}
-                        */ (/** @type {any} */ obj) => Types['CarHeader > roots (anon)'](obj),
+                        */ (/** @type {any} */ obj) => Types$1['CarHeader > roots (anon)'](obj),
   CarHeader: /**
               * @param {any} obj
               * @returns {boolean}
-              */ (/** @type {any} */ obj) => { const keys = obj && Object.keys(obj); return Kinds.Map(obj) && ['version'].every((k) => keys.includes(k)) && Object.entries(obj).every(([name, value]) => Types['CarHeader > ' + name] && Types['CarHeader > ' + name](value)) }
+              */ (/** @type {any} */ obj) => { const keys = obj && Object.keys(obj); return Kinds$1.Map(obj) && ['version'].every((k) => keys.includes(k)) && Object.entries(obj).every(([name, value]) => Types$1['CarHeader > ' + name] && Types$1['CarHeader > ' + name](value)) }
 };
 
-const CarHeader = Types.CarHeader;
+const CarHeader = Types$1.CarHeader;
 
 var encode_1$1 = encode$4;
 
@@ -9812,15 +9816,15 @@ var versions = {};
 var release = {};
 var config = {};
 
-function noop$2() {}
+function noop$3() {}
 
-var on = noop$2;
-var addListener = noop$2;
-var once$2 = noop$2;
-var off = noop$2;
-var removeListener = noop$2;
-var removeAllListeners = noop$2;
-var emit = noop$2;
+var on = noop$3;
+var addListener = noop$3;
+var once$2 = noop$3;
+var off = noop$3;
+var removeListener = noop$3;
+var removeAllListeners = noop$3;
+var emit = noop$3;
 
 function binding(name) {
     throw new Error('process.binding is not supported');
@@ -12059,14 +12063,14 @@ function once$1(callback) {
     callback.apply(this, args);
   };
 }
-function noop$1() {}
+function noop$2() {}
 function isRequest$1(stream) {
   return stream.setHeader && typeof stream.abort === 'function';
 }
 function eos$1(stream, opts, callback) {
   if (typeof opts === 'function') return eos$1(stream, null, opts);
   if (!opts) opts = {};
-  callback = once$1(callback || noop$1);
+  callback = once$1(callback || noop$2);
   let readable = opts.readable || opts.readable !== false && stream.readable;
   let writable = opts.writable || opts.writable !== false && stream.writable;
   const onlegacyfinish = () => {
@@ -13495,7 +13499,7 @@ function once(callback) {
 const _require$codes = errorsBrowser.codes,
   ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
   ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
-function noop(err) {
+function noop$1(err) {
   // Rethrow the error if it exists to avoid swallowing it
   if (err) throw err;
 }
@@ -13536,8 +13540,8 @@ function pipe(from, to) {
   return from.pipe(to);
 }
 function popCallback(streams) {
-  if (!streams.length) return noop;
-  if (typeof streams[streams.length - 1] !== 'function') return noop;
+  if (!streams.length) return noop$1;
+  if (typeof streams[streams.length - 1] !== 'function') return noop$1;
   return streams.pop();
 }
 function pipeline() {
@@ -17451,19 +17455,19 @@ utils$n.padSplit = function padSplit(num, size, group) {
   return out.join(' ');
 };
 
-var minimalisticAssert = assert$j;
+var minimalisticAssert = assert$k;
 
-function assert$j(val, msg) {
+function assert$k(val, msg) {
   if (!val)
     throw new Error(msg || 'Assertion failed');
 }
 
-assert$j.equal = function assertEqual(l, r, msg) {
+assert$k.equal = function assertEqual(l, r, msg) {
   if (l != r)
     throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));
 };
 
-var assert$i = minimalisticAssert;
+var assert$j = minimalisticAssert;
 
 function Cipher$3(options) {
   this.options = options;
@@ -17596,14 +17600,14 @@ Cipher$3.prototype._unpad = function _unpad(buffer) {
 };
 
 Cipher$3.prototype._finalDecrypt = function _finalDecrypt() {
-  assert$i.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt');
+  assert$j.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt');
   var out = new Array(this.blockSize);
   this._flushBuffer(out, 0);
 
   return this._unpad(out);
 };
 
-var assert$h = minimalisticAssert;
+var assert$i = minimalisticAssert;
 var inherits$h = require$$3$1;
 
 var utils$m = utils$n;
@@ -17637,7 +17641,7 @@ var shiftTable = [
 DES$3.prototype.deriveKeys = function deriveKeys(state, key) {
   state.keys = new Array(16 * 2);
 
-  assert$h.equal(key.length, this.blockSize, 'Invalid key length');
+  assert$i.equal(key.length, this.blockSize, 'Invalid key length');
 
   var kL = utils$m.readUInt32BE(key, 0);
   var kR = utils$m.readUInt32BE(key, 4);
@@ -17687,7 +17691,7 @@ DES$3.prototype._pad = function _pad(buffer, off) {
 DES$3.prototype._unpad = function _unpad(buffer) {
   var pad = buffer[buffer.length - 1];
   for (var i = buffer.length - pad; i < buffer.length; i++)
-    assert$h.equal(buffer[i], pad);
+    assert$i.equal(buffer[i], pad);
 
   return buffer.slice(0, buffer.length - pad);
 };
@@ -17746,13 +17750,13 @@ DES$3.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) {
 
 var cbc$1 = {};
 
-var assert$g = minimalisticAssert;
+var assert$h = minimalisticAssert;
 var inherits$g = require$$3$1;
 
 var proto = {};
 
 function CBCState(iv) {
-  assert$g.equal(iv.length, 8, 'Invalid IV length');
+  assert$h.equal(iv.length, 8, 'Invalid IV length');
 
   this.iv = new Array(8);
   for (var i = 0; i < this.iv.length; i++)
@@ -17810,14 +17814,14 @@ proto._update = function _update(inp, inOff, out, outOff) {
   }
 };
 
-var assert$f = minimalisticAssert;
+var assert$g = minimalisticAssert;
 var inherits$f = require$$3$1;
 
 var Cipher$1 = cipher;
 var DES$2 = des$1;
 
 function EDEState(type, key) {
-  assert$f.equal(key.length, 24, 'Invalid key length');
+  assert$g.equal(key.length, 24, 'Invalid key length');
 
   var k1 = key.slice(0, 8);
   var k2 = key.slice(8, 16);
@@ -26921,7 +26925,7 @@ var BN$9 = bnExports$1;
 var utils$j = utils$l;
 var getNAF = utils$j.getNAF;
 var getJSF = utils$j.getJSF;
-var assert$e = utils$j.assert;
+var assert$f = utils$j.assert;
 
 function BaseCurve(type, conf) {
   this.type = type;
@@ -26967,7 +26971,7 @@ BaseCurve.prototype.validate = function validate() {
 };
 
 BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
-  assert$e(p.precomputed);
+  assert$f(p.precomputed);
   var doubles = p._getDoubles();
 
   var naf = getNAF(k, 1, this._bitLength);
@@ -27024,7 +27028,7 @@ BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
     if (i < 0)
       break;
     var z = naf[i];
-    assert$e(z !== 0);
+    assert$f(z !== 0);
     if (p.type === 'affine') {
       // J +- P
       if (z > 0)
@@ -27192,9 +27196,9 @@ BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
   if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&
       bytes.length - 1 === 2 * len) {
     if (bytes[0] === 0x06)
-      assert$e(bytes[bytes.length - 1] % 2 === 0);
+      assert$f(bytes[bytes.length - 1] % 2 === 0);
     else if (bytes[0] === 0x07)
-      assert$e(bytes[bytes.length - 1] % 2 === 1);
+      assert$f(bytes[bytes.length - 1] % 2 === 1);
 
     var res =  this.point(bytes.slice(1, 1 + len),
       bytes.slice(1 + len, 1 + 2 * len));
@@ -27301,7 +27305,7 @@ var BN$8 = bnExports$1;
 var inherits$9 = require$$3$1;
 var Base$2 = base$2;
 
-var assert$d = utils$i.assert;
+var assert$e = utils$i.assert;
 
 function ShortCurve(conf) {
   Base$2.call(this, 'short', conf);
@@ -27346,7 +27350,7 @@ ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
       lambda = lambdas[0];
     } else {
       lambda = lambdas[1];
-      assert$d(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
+      assert$e(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
     }
   }
 
@@ -28415,7 +28419,7 @@ var BN$6 = bnExports$1;
 var inherits$7 = require$$3$1;
 var Base = base$2;
 
-var assert$c = utils$g.assert;
+var assert$d = utils$g.assert;
 
 function EdwardsCurve(conf) {
   // NOTE: Important as we are creating point in Base.call()
@@ -28432,7 +28436,7 @@ function EdwardsCurve(conf) {
   this.d = new BN$6(conf.d, 16).toRed(this.red);
   this.dd = this.d.redAdd(this.d);
 
-  assert$c(!this.twisted || this.c.fromRed().cmpn(1) === 0);
+  assert$d(!this.twisted || this.c.fromRed().cmpn(1) === 0);
   this.oneC = (conf.c | 0) === 1;
 }
 inherits$7(EdwardsCurve, Base);
@@ -28860,7 +28864,7 @@ var hash$2 = {};
 
 var utils$f = {};
 
-var assert$b = minimalisticAssert;
+var assert$c = minimalisticAssert;
 var inherits$6 = require$$3$1;
 
 utils$f.inherits = inherits$6;
@@ -28981,7 +28985,7 @@ utils$f.zero8 = zero8;
 
 function join32(msg, start, end, endian) {
   var len = end - start;
-  assert$b(len % 4 === 0);
+  assert$c(len % 4 === 0);
   var res = new Array(len / 4);
   for (var i = 0, k = start; i < res.length; i++, k += 4) {
     var w;
@@ -29140,7 +29144,7 @@ utils$f.shr64_lo = shr64_lo$1;
 var common$6 = {};
 
 var utils$e = utils$f;
-var assert$a = minimalisticAssert;
+var assert$b = minimalisticAssert;
 
 function BlockHash$4() {
   this.pending = null;
@@ -29185,7 +29189,7 @@ BlockHash$4.prototype.update = function update(msg, enc) {
 
 BlockHash$4.prototype.digest = function digest(enc) {
   this.update(this._pad());
-  assert$a(this.pending === null);
+  assert$b(this.pending === null);
 
   return this._digest(enc);
 };
@@ -29358,7 +29362,7 @@ SHA1.prototype._digest = function digest(enc) {
 var utils$b = utils$f;
 var common$3 = common$6;
 var shaCommon = common$5;
-var assert$9 = minimalisticAssert;
+var assert$a = minimalisticAssert;
 
 var sum32$1 = utils$b.sum32;
 var sum32_4$1 = utils$b.sum32_4;
@@ -29428,7 +29432,7 @@ SHA256$1.prototype._update = function _update(msg, start) {
   var g = this.h[6];
   var h = this.h[7];
 
-  assert$9(this.k.length === W.length);
+  assert$a(this.k.length === W.length);
   for (i = 0; i < W.length; i++) {
     var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
     var T2 = sum32$1(s0_256(a), maj32(a, b, c));
@@ -29489,7 +29493,7 @@ SHA224.prototype._digest = function digest(enc) {
 
 var utils$9 = utils$f;
 var common$2 = common$6;
-var assert$8 = minimalisticAssert;
+var assert$9 = minimalisticAssert;
 
 var rotr64_hi = utils$9.rotr64_hi;
 var rotr64_lo = utils$9.rotr64_lo;
@@ -29624,7 +29628,7 @@ SHA512$1.prototype._update = function _update(msg, start) {
   var hh = this.h[14];
   var hl = this.h[15];
 
-  assert$8(this.k.length === W.length);
+  assert$9(this.k.length === W.length);
   for (var i = 0; i < W.length; i += 2) {
     var c0_hi = hh;
     var c0_lo = hl;
@@ -30004,7 +30008,7 @@ var sh = [
 ];
 
 var utils$6 = utils$f;
-var assert$7 = minimalisticAssert;
+var assert$8 = minimalisticAssert;
 
 function Hmac(hash, key, enc) {
   if (!(this instanceof Hmac))
@@ -30023,7 +30027,7 @@ Hmac.prototype._init = function init(key) {
   // Shorten key, if needed
   if (key.length > this.blockSize)
     key = new this.Hash().update(key).digest();
-  assert$7(key.length <= this.blockSize);
+  assert$8(key.length <= this.blockSize);
 
   // Add padding to key
   for (var i = key.length; i < this.blockSize; i++)
@@ -31066,7 +31070,7 @@ function requireSecp256k1 () {
 
 var hash$1 = hash$2;
 var utils$5 = utils$k;
-var assert$6 = minimalisticAssert;
+var assert$7 = minimalisticAssert;
 
 function HmacDRBG(options) {
   if (!(this instanceof HmacDRBG))
@@ -31085,7 +31089,7 @@ function HmacDRBG(options) {
   var entropy = utils$5.toArray(options.entropy, options.entropyEnc || 'hex');
   var nonce = utils$5.toArray(options.nonce, options.nonceEnc || 'hex');
   var pers = utils$5.toArray(options.pers, options.persEnc || 'hex');
-  assert$6(entropy.length >= (this.minEntropy / 8),
+  assert$7(entropy.length >= (this.minEntropy / 8),
          'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
   this._init(entropy, nonce, pers);
 }
@@ -31140,7 +31144,7 @@ HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
   entropy = utils$5.toArray(entropy, entropyEnc);
   add = utils$5.toArray(add, addEnc);
 
-  assert$6(entropy.length >= (this.minEntropy / 8),
+  assert$7(entropy.length >= (this.minEntropy / 8),
          'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
 
   this._update(entropy.concat(add || []));
@@ -31178,7 +31182,7 @@ HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
 
 var BN$5 = bnExports$1;
 var utils$4 = utils$l;
-var assert$5 = utils$4.assert;
+var assert$6 = utils$4.assert;
 
 function KeyPair$2(ec, options) {
   this.ec = ec;
@@ -31263,10 +31267,10 @@ KeyPair$2.prototype._importPublic = function _importPublic(key, enc) {
     // Weierstrass/Edwards points on the other hand have both `x` and
     // `y` coordinates.
     if (this.ec.curve.type === 'mont') {
-      assert$5(key.x, 'Need x coordinate');
+      assert$6(key.x, 'Need x coordinate');
     } else if (this.ec.curve.type === 'short' ||
                this.ec.curve.type === 'edwards') {
-      assert$5(key.x && key.y, 'Need both x and y coordinate');
+      assert$6(key.x && key.y, 'Need both x and y coordinate');
     }
     this.pub = this.ec.curve.point(key.x, key.y);
     return;
@@ -31277,7 +31281,7 @@ KeyPair$2.prototype._importPublic = function _importPublic(key, enc) {
 // ECDH
 KeyPair$2.prototype.derive = function derive(pub) {
   if(!pub.validate()) {
-    assert$5(pub.validate(), 'public point not validated');
+    assert$6(pub.validate(), 'public point not validated');
   }
   return pub.mul(this.priv).getX();
 };
@@ -31299,7 +31303,7 @@ KeyPair$2.prototype.inspect = function inspect() {
 var BN$4 = bnExports$1;
 
 var utils$3 = utils$l;
-var assert$4 = utils$3.assert;
+var assert$5 = utils$3.assert;
 
 function Signature$2(options, enc) {
   if (options instanceof Signature$2)
@@ -31308,7 +31312,7 @@ function Signature$2(options, enc) {
   if (this._importDER(options, enc))
     return;
 
-  assert$4(options.r && options.s, 'Signature without r or s');
+  assert$5(options.r && options.s, 'Signature without r or s');
   this.r = new BN$4(options.r, 16);
   this.s = new BN$4(options.s, 16);
   if (options.recoveryParam === undefined)
@@ -31713,7 +31717,7 @@ function requireEc () {
 }
 
 var utils$2 = utils$l;
-var assert$3 = utils$2.assert;
+var assert$4 = utils$2.assert;
 var parseBytes$2 = utils$2.parseBytes;
 var cachedProperty$1 = utils$2.cachedProperty;
 
@@ -31787,7 +31791,7 @@ cachedProperty$1(KeyPair$1, 'messagePrefix', function messagePrefix() {
 });
 
 KeyPair$1.prototype.sign = function sign(message) {
-  assert$3(this._secret, 'KeyPair can only verify');
+  assert$4(this._secret, 'KeyPair can only verify');
   return this.eddsa.sign(message, this);
 };
 
@@ -31796,7 +31800,7 @@ KeyPair$1.prototype.verify = function verify(message, sig) {
 };
 
 KeyPair$1.prototype.getSecret = function getSecret(enc) {
-  assert$3(this._secret, 'KeyPair is public only');
+  assert$4(this._secret, 'KeyPair is public only');
   return utils$2.encode(this.secret(), enc);
 };
 
@@ -31808,7 +31812,7 @@ var key$1 = KeyPair$1;
 
 var BN$3 = bnExports$1;
 var utils$1 = utils$l;
-var assert$2 = utils$1.assert;
+var assert$3 = utils$1.assert;
 var cachedProperty = utils$1.cachedProperty;
 var parseBytes$1 = utils$1.parseBytes;
 
@@ -31833,7 +31837,7 @@ function Signature$1(eddsa, sig) {
     };
   }
 
-  assert$2(sig.R && sig.S, 'Signature without R or S');
+  assert$3(sig.R && sig.S, 'Signature without R or S');
 
   if (eddsa.isPoint(sig.R))
     this._R = sig.R;
@@ -31873,13 +31877,13 @@ var signature = Signature$1;
 var hash = hash$2;
 var curves = curves$1;
 var utils = utils$l;
-var assert$1 = utils.assert;
+var assert$2 = utils.assert;
 var parseBytes = utils.parseBytes;
 var KeyPair = key$1;
 var Signature = signature;
 
 function EDDSA(curve) {
-  assert$1(curve === 'ed25519', 'only tested with ed25519 so far');
+  assert$2(curve === 'ed25519', 'only tested with ed25519 so far');
 
   if (!(this instanceof EDDSA))
     return new EDDSA(curve);
@@ -32374,7 +32378,7 @@ EncoderBuffer$1.prototype.join = function join(out, offset) {
 const Reporter = reporter.Reporter;
 const EncoderBuffer = buffer.EncoderBuffer;
 const DecoderBuffer$1 = buffer.DecoderBuffer;
-const assert = minimalisticAssert;
+const assert$1 = minimalisticAssert;
 
 // Supported tags
 const tags = [
@@ -32465,14 +32469,14 @@ Node$2.prototype._wrap = function wrap() {
 Node$2.prototype._init = function init(body) {
   const state = this._baseState;
 
-  assert(state.parent === null);
+  assert$1(state.parent === null);
   body.call(this);
 
   // Filter children
   state.children = state.children.filter(function(child) {
     return child._baseState.parent === this;
   }, this);
-  assert.equal(state.children.length, 1, 'Root node can have only one child');
+  assert$1.equal(state.children.length, 1, 'Root node can have only one child');
 };
 
 Node$2.prototype._useArgs = function useArgs(args) {
@@ -32487,7 +32491,7 @@ Node$2.prototype._useArgs = function useArgs(args) {
   }, this);
 
   if (children.length !== 0) {
-    assert(state.children === null);
+    assert$1(state.children === null);
     state.children = children;
 
     // Replace parent to maintain backward link
@@ -32496,7 +32500,7 @@ Node$2.prototype._useArgs = function useArgs(args) {
     }, this);
   }
   if (args.length !== 0) {
-    assert(state.args === null);
+    assert$1(state.args === null);
     state.args = args;
     state.reverseArgs = args.map(function(arg) {
       if (typeof arg !== 'object' || arg.constructor !== Object)
@@ -32534,7 +32538,7 @@ tags.forEach(function(tag) {
     const state = this._baseState;
     const args = Array.prototype.slice.call(arguments);
 
-    assert(state.tag === null);
+    assert$1(state.tag === null);
     state.tag = tag;
 
     this._useArgs(args);
@@ -32544,10 +32548,10 @@ tags.forEach(function(tag) {
 });
 
 Node$2.prototype.use = function use(item) {
-  assert(item);
+  assert$1(item);
   const state = this._baseState;
 
-  assert(state.use === null);
+  assert$1(state.use === null);
   state.use = item;
 
   return this;
@@ -32564,7 +32568,7 @@ Node$2.prototype.optional = function optional() {
 Node$2.prototype.def = function def(val) {
   const state = this._baseState;
 
-  assert(state['default'] === null);
+  assert$1(state['default'] === null);
   state['default'] = val;
   state.optional = true;
 
@@ -32574,7 +32578,7 @@ Node$2.prototype.def = function def(val) {
 Node$2.prototype.explicit = function explicit(num) {
   const state = this._baseState;
 
-  assert(state.explicit === null && state.implicit === null);
+  assert$1(state.explicit === null && state.implicit === null);
   state.explicit = num;
 
   return this;
@@ -32583,7 +32587,7 @@ Node$2.prototype.explicit = function explicit(num) {
 Node$2.prototype.implicit = function implicit(num) {
   const state = this._baseState;
 
-  assert(state.explicit === null && state.implicit === null);
+  assert$1(state.explicit === null && state.implicit === null);
   state.implicit = num;
 
   return this;
@@ -32604,7 +32608,7 @@ Node$2.prototype.obj = function obj() {
 Node$2.prototype.key = function key(newKey) {
   const state = this._baseState;
 
-  assert(state.key === null);
+  assert$1(state.key === null);
   state.key = newKey;
 
   return this;
@@ -32621,7 +32625,7 @@ Node$2.prototype.any = function any() {
 Node$2.prototype.choice = function choice(obj) {
   const state = this._baseState;
 
-  assert(state.choice === null);
+  assert$1(state.choice === null);
   state.choice = obj;
   this._useArgs(Object.keys(obj).map(function(key) {
     return obj[key];
@@ -32633,7 +32637,7 @@ Node$2.prototype.choice = function choice(obj) {
 Node$2.prototype.contains = function contains(item) {
   const state = this._baseState;
 
-  assert(state.use === null);
+  assert$1(state.use === null);
   state.contains = item;
 
   return this;
@@ -32806,7 +32810,7 @@ Node$2.prototype._getUse = function _getUse(entity, obj) {
   const state = this._baseState;
   // Create altered use decoder if implicit is set
   state.useDecoder = this._use(entity, obj);
-  assert(state.useDecoder._baseState.parent === null);
+  assert$1(state.useDecoder._baseState.parent === null);
   state.useDecoder = state.useDecoder._baseState.children[0];
   if (state.implicit !== state.useDecoder._baseState.implicit) {
     state.useDecoder = state.useDecoder.clone();
@@ -32967,7 +32971,7 @@ Node$2.prototype._encodeChoice = function encodeChoice(data, reporter) {
 
   const node = state.choice[data.type];
   if (!node) {
-    assert(
+    assert$1(
       false,
       data.type + ' not found in ' +
             JSON.stringify(Object.keys(state.choice)));
@@ -36085,7 +36089,7 @@ const coerce = o => {
   throw new Error('Unknown type, must be binary type');
 };
 
-const create$2 = (code, digest) => {
+const create$4 = (code, digest) => {
   const size = digest.byteLength;
   const sizeOffset = encodingLength(code);
   const digestOffset = sizeOffset + encodingLength(size);
@@ -36461,7 +36465,7 @@ class CID {
     switch (this.version) {
     case 0: {
         const {code, digest} = this.multihash;
-        const multihash = create$2(code, digest);
+        const multihash = create$4(code, digest);
         return CID.createV1(this.code, multihash);
       }
     case 1: {
@@ -36884,7 +36888,7 @@ const createGetNode = (get, cache, chunker, codec, hasher) => {
   };
   return getNode;
 };
-const create$1 = ({get, cache, chunker, list, codec, hasher, sorted}) => {
+const create$3 = ({get, cache, chunker, list, codec, hasher, sorted}) => {
   if (!sorted)
     list = list.sort(compare$2);
   const getNode = createGetNode(get, cache, chunker, codec, hasher);
@@ -36902,16 +36906,16 @@ const create$1 = ({get, cache, chunker, list, codec, hasher, sorted}) => {
     BranchClass: CIDSetBranch,
     BranchEntryClass: CIDNodeEntry
   };
-  return create$4(opts);
+  return create$6(opts);
 };
-const load$1 = ({cid, get, cache, chunker, codec, hasher, ...opts}) => {
+const load$3 = ({cid, get, cache, chunker, codec, hasher, ...opts}) => {
   const getNode = createGetNode(get, cache, chunker, codec, hasher);
   return getNode(cid);
 };
 
 // @ts-nocheck
 
-const createBlock = (bytes, cid) => create$5({ cid, bytes, hasher: sha256$2, codec });
+const createBlock = (bytes, cid) => create$7({ cid, bytes, hasher: sha256$2, codec });
 
 const encrypt = async function * ({ get, cids, hasher, key, cache, chunker, root }) {
   const set = new Set();
@@ -36928,7 +36932,7 @@ const encrypt = async function * ({ get, cids, hasher, key, cache, chunker, root
   if (!eroot) throw new Error('cids does not include root')
   const list = [...set].map(s => CID$1.parse(s));
   let last;
-  for await (const node of create$1({ list, get, cache, chunker, hasher, codec: codec$1 })) {
+  for await (const node of create$3({ list, get, cache, chunker, hasher, codec: codec$1 })) {
     const block = await node.block;
     yield block;
     last = block;
@@ -36944,7 +36948,7 @@ const decrypt = async function * ({ root, get, key, cache, chunker, hasher }) {
   // console.log('decodedRoot', decodedRoot)
   const { value: [eroot, tree] } = decodedRoot;
   const rootBlock = await get(eroot); // should I decrypt?
-  const cidset = await load$1({ cid: tree, get, cache, chunker, codec, hasher });
+  const cidset = await load$3({ cid: tree, get, cache, chunker, codec, hasher });
   const { result: nodes } = await cidset.getAllEntries();
   const unwrap = async (eblock) => {
     const { bytes, cid } = await decrypt$1({ ...eblock, key }).catch(e => {
@@ -36962,321 +36966,2925 @@ const decrypt = async function * ({ root, get, key, cache, chunker, hasher }) {
   yield unwrap(rootBlock);
 };
 
-// @ts-nocheck
-// from https://github.com/duzun/sync-sha1/blob/master/rawSha1.js
-// MIT License Copyright (c) 2020 Dumitru Uzun
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+var bitUtils = {};
 
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} bitStart
+ * @param {number} bitLength
+ * @returns {number}
+ */
 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
+function bitSequence$1 (bytes, bitStart, bitLength) {
+  // making an assumption that bytes is an Array-like that will give us one
+  // byte per element, so either an Array full of 8-bit integers or a
+  // Uint8Array or a Node.js Buffer, or something like that
 
-// import {
-//   isLittleEndian, switchEndianness32
-// } from 'string-encode'
+  const startOffset = bitStart % 8;
+  const byteCount = Math.ceil((startOffset + bitLength) / 8);
+  const byteStart = bitStart >> 3;
+  const endOffset = byteCount * 8 - bitLength - startOffset;
+
+  let result = 0;
+
+  for (let i = 0; i < byteCount; i++) {
+    let local = bytes[byteStart + i];
+    let shift = 0;
+    let localBitLength = 8; // how many bits of this byte we are extracting
+
+    if (i === 0) {
+      localBitLength -= startOffset;
+    }
+
+    if (i === byteCount - 1) {
+      localBitLength -= endOffset;
+      shift = endOffset;
+      local >>= shift; // take off the trailing bits
+    }
+
+    if (localBitLength < 8) {
+      const mask = (1 << localBitLength) - 1;
+      local &= mask; // mask off the leading bits
+    }
+
+    if (i < 3) {
+      if (shift < 8) {
+        result = result << (8 - shift);
+      }
+      result |= local;
+    } else {
+      // once we start shifting beyond the 24-bit range we get to signed integers
+      // and our bitwise operations break down, because JavaScript. But if we do
+      // it without bitwise operations then we can cheat into very large numbers
+      if (shift < 8) {
+        result = result * Math.pow(2, (8 - shift));
+      }
+      result += local;
+    }
+  }
+
+  return result
+}
+
+var bitSequence_1 = bitSequence$1;
+
+// Copyright Rod Vagg; Licensed under the Apache License, Version 2.0, see README.md for more information
+
+const bitSequence = bitSequence_1;
 
 /**
-* SHA1 on binary array
-*
-* @param   {Uint8Array}  b  Data to hash
-*
-* @return  {Uint8Array}  sha1 hash
-*/
-function rawSha1 (b) {
-  let i = b.byteLength;
-  let bs = 0;
-  let A; let B; let C; let D; let G;
-  const H = Uint32Array.from([A = 0x67452301, B = 0xEFCDAB89, ~A, ~B, 0xC3D2E1F0]);
-  const W = new Uint32Array(80);
-  const nrWords = (i / 4 + 2) | 15;
-  const words = new Uint32Array(nrWords + 1);
-  let j;
+ * @param {Uint8Array} hash
+ * @param {number} depth
+ * @param {number} nbits
+ * @returns {number}
+ */
+function mask$1 (hash, depth, nbits) {
+  return bitSequence(hash, depth * nbits, nbits)
+}
 
-  words[nrWords] = i * 8;
-  words[i >> 2] |= 0x80 << (~i << 3);
-  for (;i--;) {
-    words[i >> 2] |= b[i] << (~i << 3);
+/**
+ * set the `position` bit in the given `bitmap` to be `set` (truthy=1, falsey=0)
+ * @param {Uint8Array} bitmap
+ * @param {number} position
+ * @param {boolean|0|1} set
+ * @returns {Uint8Array}
+ */
+function setBit$1 (bitmap, position, set) {
+  // if we assume that `bitmap` is already the opposite of `set`, we could skip this check
+  const byte = Math.floor(position / 8);
+  const offset = position % 8;
+  const has = bitmapHas$1(bitmap, undefined, byte, offset);
+  if ((set && !has) || (!set && has)) {
+    const newBitmap = Uint8Array.from(bitmap);
+    let b = bitmap[byte];
+    if (set) {
+      b |= (1 << offset);
+    } else {
+      b ^= (1 << offset);
+    }
+    newBitmap[byte] = b;
+    return newBitmap
   }
+  return bitmap
+}
 
-  for (A = H.slice(); bs < nrWords; bs += 16, A.set(H)) {
-    for (i = 0; i < 80;
-      A[0] = (
-        G = ((b = A[0]) << 5 | b >>> 27) +
-                  A[4] +
-                  (W[i] = (i < 16) ? words[bs + i] : G << 1 | G >>> 31) +
-                  0x5A827999,
-        B = A[1],
-        C = A[2],
-        D = A[3],
-        G + ((j = i / 5 >> 2) // eslint-disable-line no-cond-assign
-          ? j !== 2
-            ? (B ^ C ^ D) + (j & 2 ? 0x6FE0483D : 0x14577208)
-            : (B & C | B & D | C & D) + 0x34994343
-          : B & C | ~B & D
-        )
-      )
-      , A[1] = b
-      , A[2] = B << 30 | B >>> 2
-      , A[3] = C
-      , A[4] = D
-      , ++i
-    ) {
-      G = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+/**
+ * check whether `bitmap` has a `1` at the given `position` bit
+ * @param {Uint8Array} bitmap
+ * @param {number} [position]
+ * @param {number} [byte]
+ * @param {number} [offset]
+ * @returns {boolean}
+ */
+function bitmapHas$1 (bitmap, position, byte, offset) {
+  if (typeof byte !== 'number' || typeof offset !== 'number') {
+    /* c8 ignore next 3 */
+    if (position === undefined) {
+      throw new Error('`position` expected')
     }
+    byte = Math.floor(position / 8);
+    offset = position % 8;
+  }
+  return ((bitmap[byte] >> offset) & 1) === 1
+}
 
-    for (i = 5; i;) H[--i] = H[i] + A[i];
+/**
+ * count how many `1` bits are in `bitmap up until `position`
+ * tells us where in the compacted element array an element should live
+ * TODO: optimize with a popcount on a `position` shifted bitmap?
+ * assumes bitmapHas(bitmap, position) == true, hence the i<position and +1 in the return
+ * @param {Uint8Array} bitmap
+ * @param {number} position
+ * @returns {number}
+ */
+function index$1 (bitmap, position) {
+  let t = 0;
+  for (let i = 0; i < position; i++) {
+    if (bitmapHas$1(bitmap, i)) {
+      t++;
+    }
   }
+  return t
+}
 
-  // if (isLittleEndian()) {
-  //   H = H.map(switchEndianness32)
-  // }
+bitUtils.mask = mask$1;
+bitUtils.setBit = setBit$1;
+bitUtils.bitmapHas = bitmapHas$1;
+bitUtils.index = index$1;
 
-  return new Uint8Array(H.buffer, H.byteOffset, H.byteLength)
+// Copyright Rod Vagg; Licensed under the Apache License, Version 2.0, see README.md for more information
+
+const { mask, setBit, bitmapHas, index } = bitUtils;
+
+const defaultBitWidth = 8; // 2^8 = 256 buckets or children per node
+const defaultBucketSize = 5; // array size for a bucket of values
+
+/**
+ * @template T
+ * @typedef {import('./interface').Store<T>} Store<T>
+ */
+/**
+ * @typedef {import('./interface').Config} Config
+ * @typedef {import('./interface').Options} Options
+ * @typedef {import('./interface').SerializedKV} SerializedKV
+ * @typedef {import('./interface').SerializedElement} SerializedElement
+ * @typedef {import('./interface').SerializedNode} SerializedNode
+ * @typedef {import('./interface').SerializedRoot} SerializedRoot
+ * @typedef {(inp:Uint8Array)=>(Uint8Array|Promise<Uint8Array>)} Hasher
+ * @typedef {{ hasher: Hasher, hashBytes: number }[]} Registry
+ * @typedef {(link:any)=>boolean} IsLink
+ * @typedef {readonly Element[]} ReadonlyElement
+ * @typedef {{data?: { found: boolean, elementAt: number, element: Element, bucketIndex?: number, bucketEntry?: KV }, link?: { elementAt: number, element: Element }}} FoundElement
+ */
+
+/**
+ * @type {Registry}
+ * @ignore
+ */
+const hasherRegistry = [];
+
+const textEncoder = new TextEncoder();
+
+/**
+ * @ignore
+ * @param {boolean} condition
+ * @param {string} [message]
+ */
+function assert (condition, message) {
+  if (!condition) {
+    throw new Error(message || 'Unexpected error')
+  }
 }
 
-const chunker = bf(30);
+/**
+ * ```js
+ * let map = await iamap.create(store, options)
+ * ```
+ *
+ * Create a new IAMap instance with a backing store. This operation is asynchronous and returns a `Promise` that
+ * resolves to a `IAMap` instance.
+ *
+ * @name iamap.create
+ * @function
+ * @async
+ * @template T
+ * @param {Store<T>} store - A backing store for this Map. The store should be able to save and load a serialised
+ * form of a single node of a IAMap which is provided as a plain object representation. `store.save(node)` takes
+ * a serialisable node and should return a content address / ID for the node. `store.load(id)` serves the inverse
+ * purpose, taking a content address / ID as provided by a `save()` operation and returning the serialised form
+ * of a node which can be instantiated by IAMap. In addition, two identifier handling methods are needed:
+ * `store.isEqual(id1, id2)` is required to check the equality of the two content addresses / IDs
+ * (which may be custom for that data type). `store.isLink(obj)` is used to determine if an object is a link type
+ * that can be used for `load()` operations on the store. It is important that link types be different to standard
+ * JavaScript arrays and don't share properties used by the serialized form of an IAMap (e.g. such that a
+ * `typeof obj === 'object' && Array.isArray(obj.data)`) .This is because a node data element may either be a link to
+ * a child node, or an inlined child node, so `isLink()` should be able to determine if an object is a link, and if not,
+ * `Array.isArray(obj)` will determine if that data element is a bucket of elements, or the above object check be able
+ * to determine that an inline child node exists at the data element.
+ * The `store` object should take the following form:
+ * `{ async save(node):id, async load(id):node, isEqual(id,id):boolean, isLink(obj):boolean }`
+ * A `store` should throw an appropriately informative error when a node that is requested does not exist in the backing
+ * store.
+ *
+ * Options:
+ *   - hashAlg (number) - A [multicodec](https://github.com/multiformats/multicodec/blob/master/table.csv)
+ *     hash function identifier, e.g. `0x23` for `murmur3-32`. Hash functions must be registered with {@link iamap.registerHasher}.
+ *   - bitWidth (number, default 8) - The number of bits to extract from the hash to form a data element index at
+ *     each level of the Map, e.g. a bitWidth of 5 will extract 5 bits to be used as the data element index, since 2^5=32,
+ *     each node will store up to 32 data elements (child nodes and/or entry buckets). The maximum depth of the Map is
+ *     determined by `floor((hashBytes * 8) / bitWidth)` where `hashBytes` is the number of bytes the hash function
+ *     produces, e.g. `hashBytes=32` and `bitWidth=5` yields a maximum depth of 51 nodes. The maximum `bitWidth`
+ *     currently allowed is `8` which will store 256 data elements in each node.
+ *   - bucketSize (number, default  5) - The maximum number of collisions acceptable at each level of the Map. A
+ *     collision in the `bitWidth` index at a given depth will result in entries stored in a bucket (array). Once the
+ *     bucket exceeds `bucketSize`, a new child node is created for that index and all entries in the bucket are
+ *     pushed
+ *
+ * @param {Options} options - Options for this IAMap
+ * @param {Uint8Array} [map] - for internal use
+ * @param {number} [depth] - for internal use
+ * @param {Element[]} [data] - for internal use
+ */
+async function create$2 (store, options, map, depth, data) {
+  // map, depth and data are intended for internal use
+  const newNode = new IAMap(store, options, map, depth, data);
+  return save(store, newNode)
+}
 
-const NO_ENCRYPT = typeof process !== 'undefined' && !!process.env?.NO_ENCRYPT;
-// ? process.env.NO_ENCRYPT : import.meta && import.meta.env.VITE_NO_ENCRYPT
+/**
+ * ```js
+ * let map = await iamap.load(store, id)
+ * ```
+ *
+ * Create a IAMap instance loaded from a serialised form in a backing store. See {@link iamap.create}.
+ *
+ * @name iamap.load
+ * @function
+ * @async
+ * @template T
+ * @param {Store<T>} store - A backing store for this Map. See {@link iamap.create}.
+ * @param {any} id - An content address / ID understood by the backing `store`.
+ * @param {number} [depth=0]
+ * @param {Options} [options]
+ */
+async function load$2 (store, id, depth = 0, options) {
+  // depth and options are internal arguments that the user doesn't need to interact with
+  if (depth !== 0 && typeof options !== 'object') {
+    throw new Error('Cannot load() without options at depth > 0')
+  }
+  const serialized = await store.load(id);
+  return fromSerializable(store, id, serialized, options, depth)
+}
 
-class Valet {
-  idb = null
-  name = null
-  uploadQueue = null
-  alreadyEnqueued = new Set()
-  keyMaterial = null
-  keyId = 'null'
+/**
+ * ```js
+ * iamap.registerHasher(hashAlg, hashBytes, hasher)
+ * ```
+ *
+ * Register a new hash function. IAMap has no hash functions by default, at least one is required to create a new
+ * IAMap.
+ *
+ * @name iamap.registerHasher
+ * @function
+ * @param {number} hashAlg - A [multicodec](https://github.com/multiformats/multicodec/blob/master/table.csv) hash
+ * function identifier **number**, e.g. `0x23` for `murmur3-32`.
+ * @param {number} hashBytes - The number of bytes to use from the result of the `hasher()` function (e.g. `32`)
+ * @param {Hasher} hasher - A hash function that takes a `Uint8Array` derived from the `key` values used for this
+ * Map and returns a `Uint8Array` (or a `Uint8Array`-like, such that each data element of the array contains a single byte value). The function
+ * may or may not be asynchronous but will be called with an `await`.
+ */
+function registerHasher (hashAlg, hashBytes, hasher) {
+  if (!Number.isInteger(hashAlg)) {
+    throw new Error('Invalid `hashAlg`')
+  }
+  if (!Number.isInteger(hashBytes)) {
+    throw new TypeError('Invalid `hashBytes`')
+  }
+  if (typeof hasher !== 'function') {
+    throw new TypeError('Invalid `hasher` function }')
+  }
+  hasherRegistry[hashAlg] = { hashBytes, hasher };
+}
 
+// simple stable key/value representation
+/**
+ * @ignore
+ */
+class KV {
   /**
-   * Function installed by the database to upload car files
-   * @type {null|function(string, Uint8Array):Promise<void>}
+   * @ignore
+   * @param {Uint8Array} key
+   * @param {any} value
    */
-  uploadFunction = null
-
-  constructor (name = 'default', keyMaterial) {
-    this.name = name;
-    this.setKeyMaterial(keyMaterial);
-    this.uploadQueue = cargoQueue(async (tasks, callback) => {
-      // console.log(
-      //   'queue worker',
-      //   tasks.length,
-      //   tasks.reduce((acc, t) => acc + t.value.length, 0)
-      // )
-      if (this.uploadFunction) {
-        // todo we can coalesce these into a single car file
-        return await this.withDB(async db => {
-          for (const task of tasks) {
-            await this.uploadFunction(task.carCid, task.value);
-            // update the indexedb to mark this car as no longer pending
-            const carMeta = await db.get('cidToCar', task.carCid);
-            delete carMeta.pending;
-            await db.put('cidToCar', carMeta);
-          }
-        })
-      }
-      callback();
-    });
+  constructor (key, value) {
+    this.key = key;
+    this.value = value;
+  }
 
-    this.uploadQueue.drain(async () => {
-      return await this.withDB(async db => {
-        const carKeys = (await db.getAllFromIndex('cidToCar', 'pending')).map(c => c.car);
-        for (const carKey of carKeys) {
-          await this.uploadFunction(carKey, await db.get('cars', carKey));
-          const carMeta = await db.get('cidToCar', carKey);
-          delete carMeta.pending;
-          await db.put('cidToCar', carMeta);
-        }
-      })
-    });
+  /**
+   * @ignore
+   * @returns {SerializedKV}
+   */
+  toSerializable () {
+    return [this.key, this.value]
   }
+}
 
-  getKeyMaterial () {
-    return this.keyMaterial
+/**
+ * @ignore
+ * @param {SerializedKV} obj
+ * @returns {KV}
+ */
+KV.fromSerializable = function (obj) {
+  assert(Array.isArray(obj));
+  assert(obj.length === 2);
+  return new KV(obj[0], obj[1])
+};
+
+// a element in the data array that each node holds, each element could be either a container of
+// an array (bucket) of KVs or a link to a child node
+class Element {
+  /**
+   * @ignore
+   * @param {KV[]} [bucket]
+   * @param {any} [link]
+   */
+  constructor (bucket, link) {
+    this.bucket = bucket || null;
+    this.link = link !== undefined ? link : null;
+    assert((this.bucket === null) === (this.link !== null));
   }
 
-  setKeyMaterial (km) {
-    if (km && !NO_ENCRYPT) {
-      const hex = Uint8Array.from(Buffer$G.from(km, 'hex'));
-      this.keyMaterial = km;
-      const hash = rawSha1(hex);
-      this.keyId = Buffer$G.from(hash).toString('hex');
+  /**
+   * @ignore
+   * @returns {SerializedElement}
+   */
+  toSerializable () {
+    if (this.bucket) {
+      return this.bucket.map((c) => {
+        return c.toSerializable()
+      })
     } else {
-      this.keyMaterial = null;
-      this.keyId = 'null';
+      assert(!IAMap.isIAMap(this.link)); // TODO: inline here
+      return this.link
     }
-    // console.trace('keyId', this.name, this.keyId)
   }
+}
+
+/**
+ * @ignore
+ * @param {IsLink} isLink
+ * @param {any} obj
+ * @returns {Element}
+ */
+Element.fromSerializable = function (isLink, obj) {
+  if (isLink(obj)) {
+    return new Element(undefined, obj)
+  } else if (Array.isArray(obj)) {
+    return new Element(obj.map(KV.fromSerializable))
+  }
+  throw new Error('Unexpected error: badly formed data element')
+};
 
+/**
+ * Immutable Asynchronous Map
+ *
+ * The `IAMap` constructor should not be used directly. Use `iamap.create()` or `iamap.load()` to instantiate.
+ *
+ * @class
+ * @template T
+ * @property {any} id - A unique identifier for this `IAMap` instance. IDs are generated by the backing store and
+ * are returned on `save()` operations.
+ * @property {number} config.hashAlg - The hash function used by this `IAMap` instance. See {@link iamap.create} for more
+ * details.
+ * @property {number} config.bitWidth - The number of bits used at each level of this `IAMap`. See {@link iamap.create}
+ * for more details.
+ * @property {number} config.bucketSize - TThe maximum number of collisions acceptable at each level of the Map.
+ * @property {Uint8Array} [map=Uint8Array] - Bitmap indicating which slots are occupied by data entries or child node links,
+ * each data entry contains an bucket of entries. Must be the appropriate size for `config.bitWidth`
+ * (`2 ** config.bitWith / 8` bytes).
+ * @property {number} [depth=0] - Depth of the current node in the IAMap, `depth` is used to extract bits from the
+ * key hashes to locate slots
+ * @property {Array} [data=[]] - Array of data elements (an internal `Element` type), each of which contains a
+ * bucket of entries or an ID of a child node
+ * See {@link iamap.create} for more details.
+ */
+class IAMap {
   /**
-   * Group the blocks into a car and write it to the valet.
-   * @param {import('./blockstore.js').InnerBlockstore} innerBlockstore
-   * @param {Set<string>} cids
-   * @returns {Promise<void>}
-   * @memberof Valet
+   * @ignore
+   * @param {Store<T>} store
+   * @param {Options} [options]
+   * @param {Uint8Array} [map]
+   * @param {number} [depth]
+   * @param {Element[]} [data]
    */
-  async writeTransaction (innerBlockstore, cids) {
-    if (innerBlockstore.lastCid) {
-      if (this.keyMaterial) {
-        // console.log('encrypting car', innerBlockstore.label)
-        // should we pass cids in instead of iterating frin innerBlockstore?
-        const newCar = await blocksToEncryptedCarBlock(innerBlockstore.lastCid, innerBlockstore, this.keyMaterial);
-        await this.parkCar(newCar.cid.toString(), newCar.bytes, cids);
-      } else {
-        const newCar = await blocksToCarBlock(innerBlockstore.lastCid, innerBlockstore);
-        await this.parkCar(newCar.cid.toString(), newCar.bytes, cids);
+  constructor (store, options, map, depth, data) {
+    if (!store || typeof store.save !== 'function' ||
+        typeof store.load !== 'function' ||
+        typeof store.isLink !== 'function' ||
+        typeof store.isEqual !== 'function') {
+      throw new TypeError('Invalid `store` option, must be of type: { save(node):id, load(id):node, isEqual(id,id):boolean, isLink(obj):boolean  }')
+    }
+    this.store = store;
+
+    /**
+     * @ignore
+     * @type {any|null}
+     */
+    this.id = null;
+    this.config = buildConfig(options);
+
+    const hashBytes = hasherRegistry[this.config.hashAlg].hashBytes;
+
+    if (map !== undefined && !(map instanceof Uint8Array)) {
+      throw new TypeError('`map` must be a Uint8Array')
+    }
+    const mapLength = Math.ceil(Math.pow(2, this.config.bitWidth) / 8);
+    if (map !== undefined && map.length !== mapLength) {
+      throw new Error('`map` must be a Uint8Array of length ' + mapLength)
+    }
+    this.map = map || new Uint8Array(mapLength);
+
+    if (depth !== undefined && (!Number.isInteger(depth) || depth < 0)) {
+      throw new TypeError('`depth` must be an integer >= 0')
+    }
+    this.depth = depth || 0;
+    if (this.depth > Math.floor((hashBytes * 8) / this.config.bitWidth)) {
+      // our hasher only has `hashBytes` to work with and we take off `bitWidth` bits with each level
+      // e.g. 32-byte hash gives us a maximum depth of 51 levels
+      throw new Error('Overflow: maximum tree depth reached')
+    }
+
+    /**
+     * @ignore
+     * @type {ReadonlyElement}
+     */
+    this.data = Object.freeze(data || []);
+    for (const e of this.data) {
+      if (!(e instanceof Element)) {
+        throw new TypeError('`data` array must contain only `Element` types')
       }
-    } else {
-      throw new Error('missing lastCid for car header')
     }
   }
 
-  withDB = async dbWorkFun => {
-    if (!this.idb) {
-      this.idb = await openDB(`fp.${this.keyId}.${this.name}.valet`, 2, {
-        upgrade (db, oldVersion, newVersion, transaction) {
-          if (oldVersion < 1) {
-            db.createObjectStore('cars'); // todo use database name
-            const cidToCar = db.createObjectStore('cidToCar', { keyPath: 'car' });
-            cidToCar.createIndex('cids', 'cids', { multiEntry: true });
+  /**
+   * Asynchronously create a new `IAMap` instance identical to this one but with `key` set to `value`.
+   *
+   * @param {(string|Uint8Array)} key - A key for the `value` being set whereby that same `value` may
+   * be retrieved with a `get()` operation with the same `key`. The type of the `key` object should either be a
+   * `Uint8Array` or be convertable to a `Uint8Array` via `TextEncoder.
+   * @param {any} value - Any value that can be stored in the backing store. A value could be a serialisable object
+   * or an address or content address or other kind of link to the actual value.
+   * @param {Uint8Array} [_cachedHash] - for internal use
+   * @returns {Promise<IAMap<T>>} A `Promise` containing a new `IAMap` that contains the new key/value pair.
+   * @async
+   */
+  async set (key, value, _cachedHash) {
+    if (!(key instanceof Uint8Array)) {
+      key = textEncoder.encode(key);
+    }
+    const hash = _cachedHash instanceof Uint8Array ? _cachedHash : await hasher(this)(key);
+    const bitpos = mask(hash, this.depth, this.config.bitWidth);
+
+    if (bitmapHas(this.map, bitpos)) { // should be in a bucket in this node
+      const { data, link } = findElement(this, bitpos, key);
+      if (data) {
+        if (data.found) {
+          /* c8 ignore next 3 */
+          if (data.bucketIndex === undefined || data.bucketEntry === undefined) {
+            throw new Error('Unexpected error')
           }
-          if (oldVersion < 2) {
-            const cidToCar = transaction.objectStore('cidToCar');
-            cidToCar.createIndex('pending', 'pending');
+          if (data.bucketEntry.value === value) {
+            return this // no change, identical value
+          }
+          // replace entry for this key with a new value
+          // note that === will fail for two complex objects representing the same data so we may end up
+          // with a node of the same ID anyway
+          return updateBucket(this, data.elementAt, data.bucketIndex, key, value)
+        } else {
+          /* c8 ignore next 3 */
+          if (!data.element.bucket) {
+            throw new Error('Unexpected error')
           }
+          if (data.element.bucket.length >= this.config.bucketSize) {
+            // too many collisions at this level, replace a bucket with a child node
+            return (await replaceBucketWithNode(this, data.elementAt)).set(key, value, hash)
+          }
+          // insert into the bucket and sort it
+          return updateBucket(this, data.elementAt, -1, key, value)
         }
-      });
+      } else if (link) {
+        const child = await load$2(this.store, link.element.link, this.depth + 1, this.config);
+        assert(!!child);
+        const newChild = await child.set(key, value, hash);
+        return updateNode(this, link.elementAt, newChild)
+      /* c8 ignore next 3 */
+      } else {
+        throw new Error('Unexpected error')
+      }
+    } else { // we don't have an element for this hash portion, make one
+      return addNewElement(this, bitpos, key, value)
     }
-    return await dbWorkFun(this.idb)
   }
 
   /**
-   * Iterate over all blocks in the store.
+   * Asynchronously find and return a value for the given `key` if it exists within this `IAMap`.
    *
-   * @yields {{cid: string, value: Uint8Array}}
-   * @returns {AsyncGenerator<any, any, any>}
+   * @param {string|Uint8Array} key - A key for the value being sought. See {@link IAMap#set} for
+   * details about acceptable `key` types.
+   * @param {Uint8Array} [_cachedHash] - for internal use
+   * @returns {Promise<any>} A `Promise` that resolves to the value being sought if that value exists within this `IAMap`. If the
+   * key is not found in this `IAMap`, the `Promise` will resolve to `undefined`.
+   * @async
    */
-  async * cids () {
-    // console.log('valet cids')
-    const db = await this.withDB(async db => db);
-    const tx = db.transaction(['cidToCar'], 'readonly');
-    let cursor = await tx.store.openCursor();
-    while (cursor) {
-      yield { cid: cursor.key, car: cursor.value.car };
-      cursor = await cursor.continue();
+  async get (key, _cachedHash) {
+    if (!(key instanceof Uint8Array)) {
+      key = textEncoder.encode(key);
+    }
+    const hash = _cachedHash instanceof Uint8Array ? _cachedHash : await hasher(this)(key);
+    const bitpos = mask(hash, this.depth, this.config.bitWidth);
+    if (bitmapHas(this.map, bitpos)) { // should be in a bucket in this node
+      const { data, link } = findElement(this, bitpos, key);
+      if (data) {
+        if (data.found) {
+          /* c8 ignore next 3 */
+          if (data.bucketIndex === undefined || data.bucketEntry === undefined) {
+            throw new Error('Unexpected error')
+          }
+          return data.bucketEntry.value
+        }
+        return undefined // not found
+      } else if (link) {
+        const child = await load$2(this.store, link.element.link, this.depth + 1, this.config);
+        assert(!!child);
+        return await child.get(key, hash)
+        /* c8 ignore next 3 */
+      } else {
+        throw new Error('Unexpected error')
+      }
+    } else { // we don't have an element for this hash portion, not found
+      return undefined
+    }
+
+    /*
+    const traversal = traverseGet(this, key, this.store.isEqual, this.store.isLink, this.depth)
+    while (true) {
+      const nextId = traversal.traverse()
+      if (!nextId) {
+        return traversal.value()
+      }
+      const child = await this.store.load(nextId)
+      assert(!!child)
+      traversal.next(child)
     }
+    */
   }
 
   /**
+   * Asynchronously find and return a boolean indicating whether the given `key` exists within this `IAMap`
    *
-   * @param {string} carCid
-   * @param {*} value
+   * @param {string|Uint8Array} key - A key to check for existence within this `IAMap`. See
+   * {@link IAMap#set} for details about acceptable `key` types.
+   * @returns {Promise<boolean>} A `Promise` that resolves to either `true` or `false` depending on whether the `key` exists
+   * within this `IAMap`.
+   * @async
    */
-  async parkCar (carCid, value, cids) {
-    await this.withDB(async db => {
-      const tx = db.transaction(['cars', 'cidToCar'], 'readwrite');
-      await tx.objectStore('cars').put(value, carCid);
-      await tx.objectStore('cidToCar').put({ pending: 'y', car: carCid, cids: Array.from(cids) });
-      return await tx.done
-    });
-    // console.log('parked car', carCid, value.length, Array.from(cids))
-    // upload to web3.storage if we have credentials
-    if (this.uploadFunction) {
-      if (this.alreadyEnqueued.has(carCid)) {
-        // console.log('already enqueued', carCid)
-        return
+  async has (key) {
+    return (await this.get(key)) !== undefined
+  }
+
+  /**
+   * Asynchronously create a new `IAMap` instance identical to this one but with `key` and its associated
+   * value removed. If the `key` does not exist within this `IAMap`, this instance of `IAMap` is returned.
+   *
+   * @param {string|Uint8Array} key - A key to remove. See {@link IAMap#set} for details about
+   * acceptable `key` types.
+   * @param {Uint8Array} [_cachedHash] - for internal use
+   * @returns {Promise<IAMap<T>>} A `Promise` that resolves to a new `IAMap` instance without the given `key` or the same `IAMap`
+   * instance if `key` does not exist within it.
+   * @async
+   */
+  async delete (key, _cachedHash) {
+    if (!(key instanceof Uint8Array)) {
+      key = textEncoder.encode(key);
+    }
+    const hash = _cachedHash instanceof Uint8Array ? _cachedHash : await hasher(this)(key);
+    assert(hash instanceof Uint8Array);
+    const bitpos = mask(hash, this.depth, this.config.bitWidth);
+
+    if (bitmapHas(this.map, bitpos)) { // should be in a bucket in this node
+      const { data, link } = findElement(this, bitpos, key);
+      if (data) {
+        if (data.found) {
+          /* c8 ignore next 3 */
+          if (data.bucketIndex === undefined) {
+            throw new Error('Unexpected error')
+          }
+          if (this.depth !== 0 && this.directNodeCount() === 0 && this.directEntryCount() === this.config.bucketSize + 1) {
+            // current node will only have this.config.bucketSize entries spread across its buckets
+            // and no child nodes, so wrap up the remaining nodes in a fresh IAMap at depth 0, it will
+            // bubble up to either become the new root node or be unpacked by a higher level
+            return collapseIntoSingleBucket(this, hash, data.elementAt, data.bucketIndex)
+          } else {
+            // we'll either have more entries left than this.config.bucketSize or we're at the root node
+            // so this is a simple bucket removal, no collapsing needed (root nodes can't be collapsed)
+            const lastInBucket = this.data.length === 1;
+            // we have at least one child node or too many entries in buckets to be collapsed
+            const newData = removeFromBucket(this.data, data.elementAt, lastInBucket, data.bucketIndex);
+            let newMap = this.map;
+            if (lastInBucket) {
+              newMap = setBit(newMap, bitpos, false);
+            }
+            return create$2(this.store, this.config, newMap, this.depth, newData)
+          }
+        } else {
+          // key would be located here according to hash, but we don't have it
+          return this
+        }
+      } else if (link) {
+        const child = await load$2(this.store, link.element.link, this.depth + 1, this.config);
+        assert(!!child);
+        const newChild = await child.delete(key, hash);
+        if (this.store.isEqual(newChild.id, link.element.link)) { // no modification
+          return this
+        }
+
+        assert(newChild.data.length > 0); // something probably went wrong in the map block above
+
+        if (newChild.directNodeCount() === 0 && newChild.directEntryCount() === this.config.bucketSize) {
+          // child got collapsed
+          if (this.directNodeCount() === 1 && this.directEntryCount() === 0) {
+            // we only had one node to collapse and the child was collapsible so end up acting the same
+            // as the child, bubble it up and it either becomes the new root or finds a parent to collapse
+            // in to (next section)
+            return newChild
+          } else {
+            // extract data elements from this returned node and merge them into ours
+            return collapseNodeInline(this, bitpos, newChild)
+          }
+        } else {
+          // simple node replacement with edited child
+          return updateNode(this, link.elementAt, newChild)
+        }
+        /* c8 ignore next 3 */
+      } else {
+        throw new Error('Unexpected error')
       }
-      // don't await this, it will be done in the queue
-      // console.log('add to queue', carCid, value.length)
-      this.uploadQueue.push({ carCid, value });
-      this.alreadyEnqueued.add(carCid);
+    } else { // we don't have an element for this hash portion
+      return this
     }
   }
 
-  remoteBlockFunction = null
-
-  async getBlock (dataCID) {
-    return await this.withDB(async db => {
-      const tx = db.transaction(['cars', 'cidToCar'], 'readonly');
-      const indexResp = await tx.objectStore('cidToCar').index('cids').get(dataCID);
-      const carCid = indexResp?.car;
-      if (!carCid) {
-        throw new Error('Missing block: ' + dataCID)
+  /**
+   * Asynchronously count the number of key/value pairs contained within this `IAMap`, including its children.
+   *
+   * @returns {Promise<number>} A `Promise` with a `number` indicating the number of key/value pairs within this `IAMap` instance.
+   * @async
+   */
+  async size () {
+    let c = 0;
+    for (const e of this.data) {
+      if (e.bucket) {
+        c += e.bucket.length;
+      } else {
+        const child = await load$2(this.store, e.link, this.depth + 1, this.config);
+        c += await child.size();
       }
-      const carBytes = await tx.objectStore('cars').get(carCid);
-      const reader = await CarReader.fromBytes(carBytes);
-      if (this.keyMaterial) {
-        const roots = await reader.getRoots();
-        const readerGetWithCodec = async cid => {
-          const got = await reader.get(cid);
-          // console.log('got.', cid.toString())
-          let useCodec = codec;
-          if (cid.toString().indexOf('bafy') === 0) {
-            useCodec = codec$1;
-          }
-          const decoded = await decode$9({
-            ...got,
-            codec: useCodec,
-            hasher: sha256$2
-          });
-          // console.log('decoded', decoded.value)
-          return decoded
-        };
-        const { blocks } = await blocksFromEncryptedCarBlock(roots[0], readerGetWithCodec, this.keyMaterial);
-        const block = blocks.find(b => b.cid.toString() === dataCID);
-        if (block) {
-          return block.bytes
+    }
+    return c
+  }
+
+  /**
+   * Asynchronously emit all keys that exist within this `IAMap`, including its children. This will cause a full
+   * traversal of all nodes.
+   *
+   * @returns {AsyncGenerator<Uint8Array>} An async iterator that yields keys. All keys will be in `Uint8Array` format regardless of which
+   * format they were inserted via `set()`.
+   * @async
+   */
+  async * keys () {
+    for (const e of this.data) {
+      if (e.bucket) {
+        for (const kv of e.bucket) {
+          yield kv.key;
         }
       } else {
-        const gotBlock = await reader.get(CID$1.parse(dataCID));
-        if (gotBlock) {
-          return gotBlock.bytes
+        const child = await load$2(this.store, e.link, this.depth + 1, this.config);
+        yield * child.keys();
+      }
+    }
+
+    // yield * traverseKV(this, 'keys', this.store.isLink)
+  }
+
+  /**
+   * Asynchronously emit all values that exist within this `IAMap`, including its children. This will cause a full
+   * traversal of all nodes.
+   *
+   * @returns {AsyncGenerator<any>} An async iterator that yields values.
+   * @async
+   */
+  async * values () {
+    for (const e of this.data) {
+      if (e.bucket) {
+        for (const kv of e.bucket) {
+          yield kv.value;
         }
+      } else {
+        const child = await load$2(this.store, e.link, this.depth + 1, this.config);
+        yield * child.values();
       }
-    })
+    }
+
+    // yield * traverseKV(this, 'values', this.store.isLink)
   }
-}
 
-const blocksToCarBlock = async (rootCids, blocks) => {
-  let size = 0;
-  if (!Array.isArray(rootCids)) {
-    rootCids = [rootCids];
+  /**
+   * Asynchronously emit all { key, value } pairs that exist within this `IAMap`, including its children. This will
+   * cause a full traversal of all nodes.
+   *
+   * @returns {AsyncGenerator<{ key: Uint8Array, value: any}>} An async iterator that yields objects with the properties `key` and `value`.
+   * @async
+   */
+  async * entries () {
+    for (const e of this.data) {
+      if (e.bucket) {
+        for (const kv of e.bucket) {
+          yield { key: kv.key, value: kv.value };
+        }
+      } else {
+        const child = await load$2(this.store, e.link, this.depth + 1, this.config);
+        yield * child.entries();
+      }
+    }
+
+    // yield * traverseKV(this, 'entries', this.store.isLink)
   }
-  const headerSize = headerLength({ roots: rootCids });
-  size += headerSize;
-  if (!Array.isArray(blocks)) {
-    blocks = Array.from(blocks.entries());
+
+  /**
+   * Asynchronously emit the IDs of this `IAMap` and all of its children.
+   *
+   * @returns {AsyncGenerator<any>} An async iterator that yields the ID of this `IAMap` and all of its children. The type of ID is
+   * determined by the backing store which is responsible for generating IDs upon `save()` operations.
+   */
+  async * ids () {
+    yield this.id;
+    for (const e of this.data) {
+      if (e.link) {
+        const child = await load$2(this.store, e.link, this.depth + 1, this.config);
+        yield * child.ids();
+      }
+    }
   }
-  for (const { cid, bytes } of blocks) {
-    // console.log(cid, bytes)
-    size += blockLength({ cid, bytes });
+
+  /**
+   * Returns a serialisable form of this `IAMap` node. The internal representation of this local node is copied into a plain
+   * JavaScript `Object` including a representation of its data array that the key/value pairs it contains as well as
+   * the identifiers of child nodes.
+   * Root nodes (depth==0) contain the full map configuration information, while intermediate and leaf nodes contain only
+   * data that cannot be inferred by traversal from a root node that already has this data (hashAlg and bucketSize -- bitWidth
+   * is inferred by the length of the `map` byte array).
+   * The backing store can use this representation to create a suitable serialised form. When loading from the backing store,
+   * `IAMap` expects to receive an object with the same layout from which it can instantiate a full `IAMap` object. Where
+   * root nodes contain the full set of data and intermediate and leaf nodes contain just the required data.
+   * For content addressable backing stores, it is expected that the same data in this serialisable form will always produce
+   * the same identifier.
+   * Note that the `map` property is a `Uint8Array` so will need special handling for some serialization forms (e.g. JSON).
+   *
+   * Root node form:
+   * ```
+   * {
+   *   hashAlg: number
+   *   bucketSize: number
+   *   hamt: [Uint8Array, Array]
+   * }
+   * ```
+   *
+   * Intermediate and leaf node form:
+   * ```
+   * [Uint8Array, Array]
+   * ```
+   *
+   * The `Uint8Array` in both forms is the 'map' used to identify the presence of an element in this node.
+   *
+   * The second element in the tuple in both forms, `Array`, is an elements array a mix of either buckets or links:
+   *
+   * * A bucket is an array of two elements, the first being a `key` of type `Uint8Array` and the second a `value`
+   *   or whatever type has been provided in `set()` operations for this `IAMap`.
+   * * A link is an object of the type that the backing store provides upon `save()` operations and can be identified
+   *   with `isLink()` calls.
+   *
+   * Buckets and links are differentiated by their "kind": a bucket is an array while a link is a "link" kind as dictated
+   * by the backing store. We use `Array.isArray()` and `store.isLink()` to perform this differentiation.
+   *
+   * @returns {SerializedNode|SerializedRoot} An object representing the internal state of this local `IAMap` node, including its links to child nodes
+   * if any.
+   */
+  toSerializable () {
+    const map = this.map;
+    const data = this.data.map((/** @type {Element} */ e) => {
+      return e.toSerializable()
+    });
+    /**
+     * @ignore
+     * @type {SerializedNode}
+     */
+    const hamt = [map, data];
+    if (this.depth !== 0) {
+      return hamt
+    }
+    /**
+     * @ignore
+     * @type {SerializedElement}
+     */
+    return {
+      hashAlg: this.config.hashAlg,
+      bucketSize: this.config.bucketSize,
+      hamt
+    }
   }
-  const buffer = new Uint8Array(size);
-  const writer = await createWriter(buffer, { headerSize });
 
-  for (const cid of rootCids) {
-    writer.addRoot(cid);
+  /**
+   * Calculate the number of entries locally stored by this node. Performs a scan of local buckets and adds up
+   * their size.
+   *
+   * @returns {number} A number representing the number of local entries.
+   */
+  directEntryCount () {
+    return this.data.reduce((/** @type {number} */ p, /** @type {Element} */ c) => {
+      return p + (c.bucket ? c.bucket.length : 0)
+    }, 0)
   }
 
-  for (const { cid, bytes } of blocks) {
-    writer.write({ cid, bytes });
+  /**
+   * Calculate the number of child nodes linked by this node. Performs a scan of the local entries and tallies up the
+   * ones containing links to child nodes.
+   *
+   * @returns {number} A number representing the number of direct child nodes
+   */
+  directNodeCount () {
+    return this.data.reduce((/** @type {number} */ p, /** @type {Element} */ c) => {
+      return p + (c.link ? 1 : 0)
+    }, 0)
   }
-  await writer.close();
-  return await encode$7({ value: writer.bytes, hasher: sha256$2, codec: raw })
-};
 
-const blocksToEncryptedCarBlock = async (innerBlockStoreClockRootCid, blocks, keyMaterial) => {
+  /**
+   * Asynchronously perform a check on this node and its children that it is in canonical format for the current data.
+   * As this uses `size()` to calculate the total number of entries in this node and its children, it performs a full
+   * scan of nodes and therefore incurs a load and deserialisation cost for each child node.
+   * A `false` result from this method suggests a flaw in the implemetation.
+   *
+   * @async
+   * @returns {Promise<boolean>} A Promise with a boolean value indicating whether this IAMap is correctly formatted.
+   */
+  async isInvariant () {
+    const size = await this.size();
+    const entryArity = this.directEntryCount();
+    const nodeArity = this.directNodeCount();
+    const arity = entryArity + nodeArity;
+    let sizePredicate = 2; // 2 == 'more than one'
+    if (nodeArity === 0) {
+      sizePredicate = Math.min(2, entryArity); // 0, 1 or 2=='more than one'
+    }
+
+    const inv1 = size - entryArity >= 2 * (arity - entryArity);
+    const inv2 = arity === 0 ? sizePredicate === 0 : true;
+    const inv3 = (arity === 1 && entryArity === 1) ? sizePredicate === 1 : true;
+    const inv4 = arity >= 2 ? sizePredicate === 2 : true;
+    const inv5 = nodeArity >= 0 && entryArity >= 0 && ((entryArity + nodeArity) === arity);
+
+    return inv1 && inv2 && inv3 && inv4 && inv5
+  }
+
+  /**
+   * A convenience shortcut to {@link iamap.fromSerializable} that uses this IAMap node instance's backing `store` and
+   * configuration `options`. Intended to be used to instantiate child IAMap nodes from a root IAMap node.
+   *
+   * @param {any} id An optional ID for the instantiated IAMap node. See {@link iamap.fromSerializable}.
+   * @param {any} serializable The serializable form of an IAMap node to be instantiated.
+   * @param {number} [depth=0] The depth of the IAMap node. See {@link iamap.fromSerializable}.
+  */
+  fromChildSerializable (id, serializable, depth) {
+    return fromSerializable(this.store, id, serializable, this.config, depth)
+  }
+}
+
+/**
+ * store a new node and assign it an ID
+ * @ignore
+ * @template T
+ * @param {Store<T>} store
+ * @param {IAMap<T>} newNode
+ * @returns {Promise<IAMap<T>>}
+ */
+async function save (store, newNode) {
+  const id = await store.save(newNode.toSerializable());
+  newNode.id = id;
+  return newNode
+}
+
+/**
+ * // utility function to avoid duplication since it's used across get(), set() and delete()
+ * { bucket: { found: true, elementAt, element, bucketIndex, bucketEntry } }
+ * { bucket: { found: false, elementAt, element } }
+ * { link: { elementAt, element } }
+ * @ignore
+ * @template T
+ * @param {IAMap<T>} node
+ * @param {number} bitpos
+ * @param {Uint8Array} key
+ * @returns {FoundElement}
+ */
+function findElement (node, bitpos, key) {
+  const elementAt = index(node.map, bitpos);
+  const element = node.data[elementAt];
+  assert(!!element);
+  if (element.bucket) { // data element
+    for (let bucketIndex = 0; bucketIndex < element.bucket.length; bucketIndex++) {
+      const bucketEntry = element.bucket[bucketIndex];
+      if (byteCompare(bucketEntry.key, key) === 0) {
+        return { data: { found: true, elementAt, element, bucketIndex, bucketEntry } }
+      }
+    }
+    return { data: { found: false, elementAt, element } }
+  }
+  assert(!!element.link);
+  return { link: { elementAt, element } }
+}
+
+/**
+ * new element for this node, i.e. first time this hash portion has been seen here
+ * @ignore
+ * @template T
+ * @param {IAMap<T>} node
+ * @param {number} bitpos
+ * @param {Uint8Array} key
+ * @param {any} value
+ * @returns {Promise<IAMap<T>>}
+ */
+async function addNewElement (node, bitpos, key, value) {
+  const insertAt = index(node.map, bitpos);
+  const newData = node.data.slice();
+  newData.splice(insertAt, 0, new Element([new KV(key, value)]));
+  const newMap = setBit(node.map, bitpos, true);
+  return create$2(node.store, node.config, newMap, node.depth, newData)
+}
+
+/**
+ * update an existing bucket with a new k/v pair
+ * @ignore
+ * @template T
+ * @param {IAMap<T>} node
+ * @param {number} elementAt
+ * @param {number} bucketAt
+ * @param {Uint8Array} key
+ * @param {any} value
+ * @returns {Promise<IAMap<T>>}
+ */
+async function updateBucket (node, elementAt, bucketAt, key, value) {
+  const oldElement = node.data[elementAt];
+  /* c8 ignore next 3 */
+  if (!oldElement.bucket) {
+    throw new Error('Unexpected error')
+  }
+  const newElement = new Element(oldElement.bucket.slice());
+  const newKv = new KV(key, value);
+  /* c8 ignore next 3 */
+  if (!newElement.bucket) {
+    throw new Error('Unexpected error')
+  }
+  if (bucketAt === -1) {
+    newElement.bucket.push(newKv);
+    // in-bucket sort is required to maintain a canonical state
+    newElement.bucket.sort((/** @type {KV} */ a, /** @type {KV} */ b) => byteCompare(a.key, b.key));
+  } else {
+    newElement.bucket[bucketAt] = newKv;
+  }
+  const newData = node.data.slice();
+  newData[elementAt] = newElement;
+  return create$2(node.store, node.config, node.map, node.depth, newData)
+}
+
+/**
+ * overflow of a bucket means it has to be replaced with a child node, tricky surgery
+ * @ignore
+ * @template T
+ * @param {IAMap<T>} node
+ * @param {number} elementAt
+ * @returns {Promise<IAMap<T>>}
+ */
+async function replaceBucketWithNode (node, elementAt) {
+  let newNode = new IAMap(node.store, node.config, undefined, node.depth + 1);
+  const element = node.data[elementAt];
+  assert(!!element);
+  /* c8 ignore next 3 */
+  if (!element.bucket) {
+    throw new Error('Unexpected error')
+  }
+  for (const c of element.bucket) {
+    newNode = await newNode.set(c.key, c.value);
+  }
+  newNode = await save(node.store, newNode);
+  const newData = node.data.slice();
+  newData[elementAt] = new Element(undefined, newNode.id);
+  return create$2(node.store, node.config, node.map, node.depth, newData)
+}
+
+/**
+ * similar to addNewElement() but for new child nodes
+ * @ignore
+ * @template T
+ * @param {IAMap<T>} node
+ * @param {number} elementAt
+ * @param {IAMap<T>} newChild
+ * @returns {Promise<IAMap<T>>}
+ */
+async function updateNode (node, elementAt, newChild) {
+  assert(!!newChild.id);
+  const newElement = new Element(undefined, newChild.id);
+  const newData = node.data.slice();
+  newData[elementAt] = newElement;
+  return create$2(node.store, node.config, node.map, node.depth, newData)
+}
+
+// take a node, extract all of its local entries and put them into a new node with a single
+// bucket; used for collapsing a node and sending it upward
+/**
+ * @ignore
+ * @template T
+ * @param {IAMap<T>} node
+ * @param {Uint8Array} hash
+ * @param {number} elementAt
+ * @param {number} bucketIndex
+ * @returns {Promise<IAMap<T>>}
+ */
+function collapseIntoSingleBucket (node, hash, elementAt, bucketIndex) {
+  // pretend it's depth=0 (it may end up being) and only 1 bucket
+  const newMap = setBit(new Uint8Array(node.map.length), mask(hash, 0, node.config.bitWidth), true);
+  /**
+   * @ignore
+   * @type {KV[]}
+   */
+  const newBucket = node.data.reduce((/** @type {KV[]} */ p, /** @type {Element} */ c, /** @type {number} */ i) => {
+    if (i === elementAt) {
+      /* c8 ignore next 3 */
+      if (!c.bucket) {
+        throw new Error('Unexpected error')
+      }
+      if (c.bucket.length === 1) { // only element in bucket, skip it
+        return p
+      } else {
+        // there's more in this bucket, make a temporary one, remove it and concat it
+        const tmpBucket = c.bucket.slice();
+        tmpBucket.splice(bucketIndex, 1);
+        return p.concat(tmpBucket)
+      }
+    } else {
+      /* c8 ignore next 3 */
+      if (!c.bucket) {
+        throw new Error('Unexpected error')
+      }
+      return p.concat(c.bucket)
+    }
+  }, /** @type {KV[]} */ []);
+  newBucket.sort((a, b) => byteCompare(a.key, b.key));
+  const newElement = new Element(newBucket);
+  return create$2(node.store, node.config, newMap, 0, [newElement])
+}
+
+// simple delete from an existing bucket in this node
+/**
+ * @ignore
+ * @param {ReadonlyElement} data
+ * @param {number} elementAt
+ * @param {boolean} lastInBucket
+ * @param {number} bucketIndex
+ * @returns {Element[]}
+ */
+function removeFromBucket (data, elementAt, lastInBucket, bucketIndex) {
+  const newData = data.slice();
+  if (!lastInBucket) {
+    // bucket will not be empty, remove only the element from it
+    const oldElement = data[elementAt];
+    /* c8 ignore next 3 */
+    if (!oldElement.bucket) {
+      throw new Error('Unexpected error')
+    }
+    const newElement = new Element(oldElement.bucket.slice());
+    /* c8 ignore next 3 */
+    if (!newElement.bucket) {
+      throw new Error('Unexpected error')
+    }
+    newElement.bucket.splice(bucketIndex, 1);
+    newData.splice(elementAt, 1, newElement); // replace old bucket
+  } else {
+    // empty bucket, just remove it
+    newData.splice(elementAt, 1);
+  }
+  return newData
+}
+
+/**
+ * a node has bubbled up from a recursive delete() and we need to extract its
+ * contents and insert it into ours
+ * @ignore
+ * @template T
+ * @param {IAMap<T>} node
+ * @param {number} bitpos
+ * @param {IAMap<T>} newNode
+ * @returns {Promise<IAMap<T>>}
+ */
+async function collapseNodeInline (node, bitpos, newNode) {
+  // assume the newNode has a single bucket and it's sorted and ready to replace the place
+  // it had in node's element array
+  assert(newNode.data.length === 1);
+  /* c8 ignore next 3 */
+  if (!newNode.data[0].bucket) {
+    throw new Error('Unexpected error')
+  }
+  const newBucket = newNode.data[0].bucket.slice();
+  const newElement = new Element(newBucket);
+  const elementIndex = index(node.map, bitpos);
+  const newData = node.data.slice();
+  newData[elementIndex] = newElement;
+
+  return create$2(node.store, node.config, node.map, node.depth, newData)
+}
+
+/**
+ * @ignore
+ * @param {Options} [options]
+ * @returns {Config}
+ */
+function buildConfig (options) {
+  /**
+   * @ignore
+   * @type {Config}
+   */
+  const config = {};
+
+  if (!options) {
+    throw new TypeError('Invalid `options` object')
+  }
+
+  if (!Number.isInteger(options.hashAlg)) {
+    throw new TypeError('Invalid `hashAlg` option')
+  }
+  if (!hasherRegistry[options.hashAlg]) {
+    throw new TypeError(`Unknown hashAlg: '${options.hashAlg}'`)
+  }
+  config.hashAlg = options.hashAlg;
+
+  if (options.bitWidth !== undefined) {
+    if (Number.isInteger(options.bitWidth)) {
+      if (options.bitWidth < 3 || options.bitWidth > 16) {
+        throw new TypeError('Invalid `bitWidth` option, must be between 3 and 16')
+      }
+      config.bitWidth = options.bitWidth;
+    } else {
+      throw new TypeError('Invalid `bitWidth` option')
+    }
+  } else {
+    config.bitWidth = defaultBitWidth;
+  }
+
+  if (options.bucketSize !== undefined) {
+    if (Number.isInteger(options.bucketSize)) {
+      if (options.bucketSize < 2) {
+        throw new TypeError('Invalid `bucketSize` option')
+      }
+      config.bucketSize = options.bucketSize;
+    } else {
+      throw new TypeError('Invalid `bucketSize` option')
+    }
+  } else {
+    config.bucketSize = defaultBucketSize;
+  }
+
+  return config
+}
+
+/**
+ * Determine if a serializable object is an IAMap root type, can be used to assert whether a data block is
+ * an IAMap before trying to instantiate it.
+ *
+ * @name iamap.isRootSerializable
+ * @function
+ * @param {any} serializable An object that may be a serialisable form of an IAMap root node
+ * @returns {boolean} An indication that the serialisable form is or is not an IAMap root node
+ */
+function isRootSerializable (serializable) {
+  return typeof serializable === 'object' &&
+    Number.isInteger(serializable.hashAlg) &&
+    Number.isInteger(serializable.bucketSize) &&
+    Array.isArray(serializable.hamt) &&
+    isSerializable(serializable.hamt)
+}
+
+/**
+ * Determine if a serializable object is an IAMap node type, can be used to assert whether a data block is
+ * an IAMap node before trying to instantiate it.
+ * This should pass for both root nodes as well as child nodes
+ *
+ * @name iamap.isSerializable
+ * @function
+ * @param {any} serializable An object that may be a serialisable form of an IAMap node
+ * @returns {boolean} An indication that the serialisable form is or is not an IAMap node
+ */
+function isSerializable (serializable) {
+  if (Array.isArray(serializable)) {
+    return serializable.length === 2 && serializable[0] instanceof Uint8Array && Array.isArray(serializable[1])
+  }
+  return isRootSerializable(serializable)
+}
+
+/**
+ * Instantiate an IAMap from a valid serialisable form of an IAMap node. The serializable should be the same as
+ * produced by {@link IAMap#toSerializable}.
+ * Serialised forms of root nodes must satisfy both {@link iamap.isRootSerializable} and {@link iamap.isSerializable}. For
+ * root nodes, the `options` parameter will be ignored and the `depth` parameter must be the default value of `0`.
+ * Serialised forms of non-root nodes must satisfy {@link iamap.isSerializable} and have a valid `options` parameter and
+ * a non-`0` `depth` parameter.
+ *
+ * @name iamap.fromSerializable
+ * @function
+ * @template T
+ * @param {Store<T>} store A backing store for this Map. See {@link iamap.create}.
+ * @param {any} id An optional ID for the instantiated IAMap node. Unlike {@link iamap.create},
+ * `fromSerializable()` does not `save()` a newly created IAMap node so an ID is not generated for it. If one is
+ * required for downstream purposes it should be provided, if the value is `null` or `undefined`, `node.id` will
+ * be `null` but will remain writable.
+ * @param {any} serializable The serializable form of an IAMap node to be instantiated
+ * @param {Options} [options=null] An options object for IAMap child node instantiation. Will be ignored for root
+ * node instantiation (where `depth` = `0`) See {@link iamap.create}.
+ * @param {number} [depth=0] The depth of the IAMap node. Where `0` is the root node and any `>0` number is a child
+ * node.
+ * @returns {IAMap<T>}
+ */
+function fromSerializable (store, id, serializable, options, depth = 0) {
+  /**
+   * @ignore
+   * @type {SerializedNode}
+   */
+  let hamt;
+  if (depth === 0) { // even if options were supplied, ignore them and use what's in the serializable
+    if (!isRootSerializable(serializable)) {
+      throw new Error('Loaded object does not appear to be an IAMap root (depth==0)')
+    }
+    // don't use passed-in options
+    options = serializableToOptions(serializable);
+    hamt = serializable.hamt;
+  } else {
+    if (!isSerializable(serializable)) {
+      throw new Error('Loaded object does not appear to be an IAMap node (depth>0)')
+    }
+    hamt = serializable;
+  }
+  const data = hamt[1].map(Element.fromSerializable.bind(null, store.isLink));
+  const node = new IAMap(store, options, hamt[0], depth, data);
+  if (id != null) {
+    node.id = id;
+  }
+  return node
+}
+
+/**
+ * @ignore
+ * @param {any} serializable
+ * @returns {Config}
+ */
+function serializableToOptions (serializable) {
+  return {
+    hashAlg: serializable.hashAlg,
+    bitWidth: Math.log2(serializable.hamt[0].length * 8), // inverse of (2**bitWidth) / 8
+    bucketSize: serializable.bucketSize
+  }
+}
+
+/**
+ * @template T
+ * @param {IAMap<T> | any} node
+ * @returns {boolean}
+ */
+IAMap.isIAMap = function isIAMap (node) {
+  return node instanceof IAMap
+};
+
+/**
+ * internal utility to fetch a map instance's hash function
+ *
+ * @ignore
+ * @template T
+ * @param {IAMap<T>} map
+ * @returns {Hasher}
+ */
+function hasher (map) {
+  return hasherRegistry[map.config.hashAlg].hasher
+}
+
+/**
+ * @ignore
+ * @param {Uint8Array} b1
+ * @param {Uint8Array} b2
+ * @returns {number}
+ */
+function byteCompare (b1, b2) {
+  let x = b1.length;
+  let y = b2.length;
+
+  for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+    if (b1[i] !== b2[i]) {
+      x = b1[i];
+      y = b2[i];
+      break
+    }
+  }
+  if (x < y) {
+    return -1
+  }
+  if (y < x) {
+    return 1
+  }
+  return 0
+}
+
+var create_1 = create$2;
+var load_1 = load$2;
+var registerHasher_1 = registerHasher;
+
+/** Auto-generated with ipld-schema-validator@1.0.1 at Tue Aug 16 2022 from IPLD Schema:
+ *
+ * # Root node layout
+ * type HashMapRoot struct {
+ *   hashAlg Int
+ *   bucketSize Int
+ *   hamt HashMapNode
+ * }
+ *
+ * # Non-root node layout
+ * type HashMapNode struct {
+ *   map Bytes
+ *   data [ Element ]
+ * } representation tuple
+ *
+ * type Element union {
+ *   | &HashMapNode link
+ *   | Bucket list
+ * } representation kinded
+ *
+ * type Bucket [ BucketEntry ]
+ *
+ * type BucketEntry struct {
+ *   key Bytes
+ *   value Any
+ * } representation tuple
+ *
+ */
+
+const Kinds = {
+  Null: /** @returns {boolean} */ (/** @type {any} */ obj) => obj === null,
+  Int: /** @returns {boolean} */ (/** @type {any} */ obj) => Number.isInteger(obj),
+  Float: /** @returns {boolean} */ (/** @type {any} */ obj) => typeof obj === 'number' && Number.isFinite(obj),
+  String: /** @returns {boolean} */ (/** @type {any} */ obj) => typeof obj === 'string',
+  Bool: /** @returns {boolean} */ (/** @type {any} */ obj) => typeof obj === 'boolean',
+  Bytes: /** @returns {boolean} */ (/** @type {any} */ obj) => obj instanceof Uint8Array,
+  Link: /** @returns {boolean} */ (/** @type {any} */ obj) => !Kinds.Null(obj) && typeof obj === 'object' && obj.asCID === obj,
+  List: /** @returns {boolean} */ (/** @type {any} */ obj) => Array.isArray(obj),
+  Map: /** @returns {boolean} */ (/** @type {any} */ obj) => !Kinds.Null(obj) && typeof obj === 'object' && obj.asCID !== obj && !Kinds.List(obj) && !Kinds.Bytes(obj)
+};
+/** @type {{ [k in string]: (obj:any)=>boolean}} */
+const Types = {
+  Int: Kinds.Int,
+  'HashMapRoot > hashAlg': /** @returns {boolean} */ (/** @type {any} */ obj) => Types.Int(obj),
+  'HashMapRoot > bucketSize': /** @returns {boolean} */ (/** @type {any} */ obj) => Types.Int(obj),
+  Bytes: Kinds.Bytes,
+  'HashMapNode > map': /** @returns {boolean} */ (/** @type {any} */ obj) => Types.Bytes(obj),
+  'Element > HashMapNode (anon)': Kinds.Link,
+  'BucketEntry > key': /** @returns {boolean} */ (/** @type {any} */ obj) => Types.Bytes(obj),
+  Any: /** @returns {boolean} */ (/** @type {any} */ obj) => (Kinds.Bool(obj) && Types.Bool(obj)) || (Kinds.String(obj) && Types.String(obj)) || (Kinds.Bytes(obj) && Types.Bytes(obj)) || (Kinds.Int(obj) && Types.Int(obj)) || (Kinds.Float(obj) && Types.Float(obj)) || (Kinds.Null(obj) && Types.Null(obj)) || (Kinds.Link(obj) && Types.Link(obj)) || (Kinds.Map(obj) && Types.AnyMap(obj)) || (Kinds.List(obj) && Types.AnyList(obj)),
+  Bool: Kinds.Bool,
+  String: Kinds.String,
+  Float: Kinds.Float,
+  Null: Kinds.Null,
+  Link: Kinds.Link,
+  AnyMap: /** @returns {boolean} */ (/** @type {any} */ obj) => Kinds.Map(obj) && Array.prototype.every.call(Object.values(obj), Types.Any),
+  AnyList: /** @returns {boolean} */ (/** @type {any} */ obj) => Kinds.List(obj) && Array.prototype.every.call(obj, Types.Any),
+  'BucketEntry > value': /** @returns {boolean} */ (/** @type {any} */ obj) => Types.Any(obj),
+  BucketEntry: /** @returns {boolean} */ (/** @type {any} */ obj) => Kinds.List(obj) && obj.length === 2 && Types['BucketEntry > key'](obj[0]) && Types['BucketEntry > value'](obj[1]),
+  Bucket: /** @returns {boolean} */ (/** @type {any} */ obj) => Kinds.List(obj) && Array.prototype.every.call(obj, Types.BucketEntry),
+  Element: /** @returns {boolean} */ (/** @type {any} */ obj) => (Kinds.Link(obj) && Types['Element > HashMapNode (anon)'](obj)) || (Kinds.List(obj) && Types.Bucket(obj)),
+  'HashMapNode > data (anon)': /** @returns {boolean} */ (/** @type {any} */ obj) => Kinds.List(obj) && Array.prototype.every.call(obj, Types.Element),
+  'HashMapNode > data': /** @returns {boolean} */ (/** @type {any} */ obj) => Types['HashMapNode > data (anon)'](obj),
+  HashMapNode: /** @returns {boolean} */ (/** @type {any} */ obj) => Kinds.List(obj) && obj.length === 2 && Types['HashMapNode > map'](obj[0]) && Types['HashMapNode > data'](obj[1]),
+  'HashMapRoot > hamt': /** @returns {boolean} */ (/** @type {any} */ obj) => Types.HashMapNode(obj),
+  HashMapRoot: /** @returns {boolean} */ (/** @type {any} */ obj) => { const keys = obj && Object.keys(obj); return Kinds.Map(obj) && ['hashAlg', 'bucketSize', 'hamt'].every((k) => keys.includes(k)) && Object.entries(obj).every(([name, value]) => Types['HashMapRoot > ' + name] && Types['HashMapRoot > ' + name](value)) }
+};
+
+const HashMapRoot = Types.HashMapRoot;
+const HashMapNode = Types.HashMapNode;
+Types.Element;
+Types.Bucket;
+Types.BucketEntry;
+
+/**
+ * @typedef {'bool'|'string'|'bytes'|'int'|'float'|'list'|'map'|'null'|'link'} RepresentationKindString
+ */
+
+/**
+ * @param {any} obj
+ * @returns {RepresentationKindString}
+ */
+function kind (obj) {
+  if (typeof obj === 'number') {
+    if (Number.isInteger(obj)) {
+      return 'int'
+    }
+    return 'float'
+  }
+  if (typeof obj === 'string') {
+    return 'string'
+  }
+  if (obj === null) {
+    return 'null'
+  }
+  if (typeof obj === 'boolean') {
+    return 'bool'
+  }
+  if (typeof obj === 'object' && obj.asCID === obj) {
+    return 'link'
+  }
+  if (obj instanceof Uint8Array) {
+    return 'bytes'
+  }
+  if (Array.isArray(obj)) {
+    return 'list'
+  }
+  if (typeof obj === 'object') {
+    return 'map'
+  }
+  throw new TypeError(`Unknown IPLD kind for value: ${JSON.stringify(obj)}`)
+}
+
+/**
+ * @typedef {import('ipld-schema/schema-schema').Schema} Schema
+ * @typedef {import('ipld-schema/schema-schema').TypeDefnLink} TypeDefnLink
+ * @typedef {import('ipld-schema/schema-schema').TypeDefnList} TypeDefnList
+ * @typedef {import('ipld-schema/schema-schema').TypeDefnMap} TypeDefnMap
+ */
+
+/**
+ * @param {any} obj
+ * @returns {{ schema: Schema, root: string }}
+ */
+function describe (obj) {
+  const description = describeObject(obj, { types: {} });
+  if (!Object.keys(description.schema.types).length) {
+    // when `obj` is a terminal type, make up a typedef for that kind so we have
+    // something to point to for our root rather than the plain typed kind
+
+    // special case for links
+    if (typeof description.root === 'object' && typeof description.root.link === 'object') {
+      const name = 'Link';
+      description.schema.types[name] = { link: {} };
+      description.root = name;
+    } else if (typeof description.root === 'string') {
+      const name = `${description.root}`;
+      // @ts-ignore
+      description.schema.types[name] = { [description.root.toLowerCase()]: {} };
+      description.root = name;
+      /* c8 ignore next 3 */
+    } else {
+      throw new Error('internal error')
+    }
+  }
+  /* c8 ignore next 3 */
+  if (typeof description.root !== 'string') {
+    throw new Error('internal error')
+  }
+  return { schema: description.schema, root: description.root }
+}
+
+/**
+ * @param {any} obj
+ * @param {Schema} schema
+ * @returns {{ schema: Schema, root: string|{ link: TypeDefnLink } }}
+ */
+function describeObject (obj, schema) {
+  const objKind = kind(obj);
+  let name = `${objKind.charAt(0).toUpperCase()}${objKind.substring(1)}`;
+
+  // terminals
+  if (objKind === 'null' ||
+      objKind === 'int' ||
+      objKind === 'bool' ||
+      objKind === 'float' ||
+      objKind === 'string' ||
+      objKind === 'bytes') {
+    return { schema, root: name }
+  }
+
+  if (objKind === 'link') {
+    return { schema, root: { link: {} } }
+  }
+
+  // 'map' || 'list'
+
+  /** @type {{ fieldName: string, root: string|{ link: TypeDefnLink }}[]} */
+  const fieldNames = [];
+  const entries = objKind === 'map'
+    ? Object.entries(obj)
+    : obj.map((/** @type {any} */ e, /** @type {number} */ i) => [`f${i}`, e]);
+  for (const [fieldName, value] of entries) {
+    fieldNames.push({ fieldName, root: describeObject(value, schema).root });
+  }
+  let unique = true;
+  for (let i = 1; i < fieldNames.length; i++) {
+    // this is a shallow assumption - that the name tells us the uniqueness, it doesn't
+    // and this will have to be improved
+    if (fieldNames[i].root !== fieldNames[i - 1].root) {
+      unique = false;
+      break
+    }
+  }
+
+  name = `${name}_1`;
+  /** @type {{ map: { keyType?: string, valueType?: string|{ link: TypeDefnLink } } }|{ list: { valueType?: string|{ link: TypeDefnLink } } }|{ struct: { fields: { [ k in string]: { type: string | { link: TypeDefnLink } } }, representation?: { tuple: {} } } } } */
+  let type;
+
+  if (unique) { // a pure map or list
+    const valueType = fieldNames.length ? fieldNames[0].root : 'Any';
+    if (objKind === 'map') {
+      type = { map: { keyType: 'String', valueType } };
+    } else if (objKind === 'list') {
+      type = { list: { valueType } };
+      /* c8 ignore next 4 */
+    } else {
+      throw new Error(`Unexpected object kind: ${objKind}`)
+    }
+  } else { // a struct with varying types
+    name = 'Struct_1';
+    type = {
+      struct: { fields: {} }
+    };
+    for (const field of fieldNames) {
+      type.struct.fields[field.fieldName] = { type: field.root };
+    }
+    if (objKind === 'list') {
+      type.struct.representation = { tuple: {} };
+    }
+  }
+
+  while (schema.types[name]) {
+    if (deepEqual(schema.types[name], type)) {
+      break
+    }
+    name = name.split('_').map((s, i) => i ? parseInt(s, 10) + 1 : s).join('_');
+  }
+  // too hard
+  // @ts-ignore
+  schema.types[name] = type;
+
+  return { schema, root: name }
+}
+
+/**
+ * @param {any} o1
+ * @param {any} o2
+ * @returns {boolean}
+ */
+function deepEqual (o1, o2) {
+  const k1 = kind(o1);
+  const k2 = kind(o2);
+  /* c8 ignore next 3 */
+  if (k1 !== k2) {
+    return false
+  }
+  switch (k1) {
+    /* c8 ignore next 1 */
+    case 'bool':
+    case 'string':
+    case 'int':
+    case 'float':
+    case 'null':
+      return o1 === o2
+    case 'map':
+      return deepEqual(Object.entries(o1), Object.entries(o2))
+    case 'list':
+      if (o1.length !== o2.length) {
+        return false
+      }
+      for (let i = 0; i < o1.length; i++) {
+        if (!deepEqual(o1[i], o2[i])) {
+          return false
+        }
+      }
+  }
+  return true
+}
+
+const noop = (s) => s;
+
+// based on prism.js syntax categories, except 'class-name' -> className
+const noopHighlighter = {
+  keyword: noop,
+  builtin: noop,
+  operator: noop,
+  number: noop,
+  string: noop,
+  // comment: noop,
+  className: noop,
+  punctuation: noop
+};
+
+function print (schema, indent = '  ', highlighter = {}) {
+  if (!schema || typeof schema.types !== 'object') {
+    throw new Error('Invalid schema')
+  }
+
+  highlighter = Object.assign({}, noopHighlighter, highlighter);
+
+  let str = '';
+
+  str += printAdvanced(schema, indent, highlighter);
+  str += printTypes(schema, indent, highlighter);
+
+  return str
+}
+
+function printAdvanced (schema, indent, highlighter) {
+  let str = '';
+
+  if (typeof schema.advanced === 'object') {
+    for (const advanced of Object.keys(schema.advanced)) {
+      str += `${highlighter.keyword('advanced')} ${highlighter.className(advanced)}\n\n`;
+    }
+  }
+
+  return str
+}
+
+function printTypes (schema, indent, highlighter) {
+  let str = '';
+
+  for (const [type, defn] of Object.entries(schema.types)) {
+    str += `${highlighter.keyword('type')} ${highlighter.className(type)} ${printType(defn, indent, highlighter)}\n\n`;
+  }
+
+  return str.replace(/\n\n$/m, '')
+}
+
+function kindFromDefinition (defn) {
+  const [kind, more] = Object.keys(defn);
+  if (!kind) {
+    throw new Error('Invalid schema, missing kind')
+  }
+  if (more !== undefined) {
+    throw new Error('Invalid schema more than one kind')
+  }
+  return kind
+}
+
+function printType (defn, indent, highlighter) {
+  const kind = kindFromDefinition(defn);
+
+  if (['map', 'list', 'link', 'copy'].includes(kind)) {
+    return printTypeTerm(defn, indent, highlighter)
+  }
+
+  if (['struct', 'union', 'enum'].includes(kind)) {
+    return `${highlighter.builtin(kind)} ${printTypeTerm(defn, indent, highlighter)}`
+  }
+
+  if ((kind === 'bytes' || kind === 'string') && defn[kind].representation && typeof defn[kind].representation.advanced === 'string') {
+    return `${kind} ${highlighter.builtin('representation')} advanced ${defn[kind].representation.advanced}`
+  }
+
+  return kind
+}
+
+function printTypeTerm (defn, indent, highlighter) {
+  if (typeof defn === 'string') {
+    return defn
+  }
+
+  const kind = kindFromDefinition(defn);
+
+  if (typeof printTypeTerm[kind] !== 'function') {
+    throw new Error(`Invalid schema unsupported kind (${kind})`)
+  }
+
+  return printTypeTerm[kind](defn[kind], indent, highlighter)
+}
+
+printTypeTerm.link = function link (defn, indent, highlighter) {
+  return `${highlighter.punctuation('&')}${printTypeTerm(defn.expectedType || 'Any', indent, highlighter)}`
+};
+
+printTypeTerm.copy = function copy (defn, indent, highlighter) {
+  return `${highlighter.operator('=')} ${defn.fromType}`
+};
+
+printTypeTerm.map = function map (defn, indent, highlighter) {
+  if (typeof defn.keyType !== 'string') {
+    throw new Error('Invalid schema, map definition needs a "keyType"')
+  }
+  if (!defn.valueType) {
+    throw new Error('Invalid schema, map definition needs a "keyType"')
+  }
+
+  const nullable = defn.valueNullable === true ? 'nullable ' : '';
+  let str = `${highlighter.punctuation('{')}${printTypeTerm(defn.keyType, indent, highlighter)}:${nullable}${printTypeTerm(defn.valueType, indent, highlighter)}${highlighter.punctuation('}')}`;
+  if (defn.representation) {
+    const repr = reprStrategy(defn);
+    if (repr === 'listpairs') {
+      str += ` ${highlighter.builtin('representation')} listpairs`;
+    } else if (repr === 'stringpairs') {
+      str += stringpairs(indent, 'map', defn.representation.stringpairs, highlighter);
+    } else if (repr === 'advanced') {
+      str += ` ${highlighter.builtin('representation')} advanced ${defn.representation.advanced}`;
+    }
+  }
+  return str
+};
+
+printTypeTerm.list = function list (defn, indent, highlighter) {
+  if (!defn.valueType) {
+    throw new Error('Invalid schema, list definition needs a "keyType"')
+  }
+
+  const nullable = defn.valueNullable === true ? 'nullable ' : '';
+  let str = `${highlighter.punctuation('[')}${nullable}${printTypeTerm(defn.valueType, indent, highlighter)}${highlighter.punctuation(']')}`;
+
+  if (defn.representation) {
+    if (reprStrategy(defn) === 'advanced') {
+      str += ` ${highlighter.builtin('representation')} advanced ${defn.representation.advanced}`;
+    }
+  }
+
+  return str
+};
+
+printTypeTerm.struct = function struct (defn, indent, highlighter) {
+  if (typeof defn.fields !== 'object') {
+    throw new Error('Invalid schema, struct requires a "fields" map')
+  }
+
+  let str = highlighter.punctuation('{');
+
+  for (const [name, fieldDefn] of Object.entries(defn.fields)) {
+    const optional = fieldDefn.optional === true ? highlighter.keyword('optional') + ' ' : '';
+    const nullable = fieldDefn.nullable === true ? highlighter.keyword('nullable') + ' ' : '';
+    let fieldRepr = '';
+    if (defn.representation && defn.representation.map && typeof defn.representation.map.fields === 'object') {
+      const fr = defn.representation.map.fields[name];
+      if (typeof fr === 'object') {
+        const hasRename = typeof fr.rename === 'string';
+        const hasImplicit = fr.implicit !== undefined;
+        if (hasRename || hasImplicit) {
+          fieldRepr = ` ${highlighter.punctuation('(')}`;
+          if (hasRename) {
+            fieldRepr += `${highlighter.keyword('rename')} ${highlighter.string(`"${fr.rename}"`)}`;
+            if (hasImplicit) {
+              fieldRepr += ' ';
+            }
+          }
+          if (hasImplicit) {
+            const impl = typeof fr.implicit === 'string'
+              ? highlighter.string(`"${fr.implicit}"`)
+              : typeof fr.implicit === 'number'
+                ? highlighter.number(fr.implicit)
+                : highlighter.keyword(fr.implicit);
+            fieldRepr += `${highlighter.keyword('implicit')} ${impl}`;
+          }
+          fieldRepr += highlighter.punctuation(')');
+        }
+      }
+    }
+
+    const fieldType = typeof fieldDefn.type === 'string' ? fieldDefn.type : printTypeTerm(fieldDefn.type, indent, highlighter);
+    str += `\n${indent}${name} ${optional}${nullable}${fieldType}${fieldRepr}`;
+  }
+
+  if (str[str.length - 1] !== highlighter.punctuation('{')) {
+    str += '\n';
+  }
+  str += highlighter.punctuation('}');
+
+  if (defn.representation) {
+    const repr = reprStrategy(defn);
+    if (repr === 'listpairs') {
+      str += ` ${highlighter.builtin('representation')} listpairs`;
+    } else if (repr === 'stringjoin') {
+      if (typeof defn.representation.stringjoin.join !== 'string') {
+        throw new Error('Invalid schema, struct stringjoin representations require an join string')
+      }
+      str += ` ${highlighter.builtin('representation')} stringjoin ${highlighter.punctuation('{')}\n`;
+      str += `${indent}join ${highlighter.string(`"${defn.representation.stringjoin.join}"`)}\n`;
+      str += fieldOrder(indent, defn.representation.stringjoin.fieldOrder, highlighter);
+      str += highlighter.punctuation('}');
+    } else if (repr === 'stringpairs') {
+      str += stringpairs(indent, 'struct', defn.representation.stringpairs, highlighter);
+    } else if (repr === 'tuple') {
+      str += ` ${highlighter.builtin('representation')} tuple`;
+      if (Array.isArray(defn.representation.tuple.fieldOrder)) {
+        str += ` ${highlighter.punctuation('{')}\n`;
+        str += fieldOrder(indent, defn.representation.tuple.fieldOrder, highlighter);
+        str += highlighter.punctuation('}');
+      }
+    } else if (repr === 'advanced') {
+      str += ` ${highlighter.builtin('representation')} advanced ${defn.representation.advanced}`;
+    }
+  }
+
+  return str
+};
+
+function fieldOrder (indent, fieldOrder, highlighter) {
+  let str = '';
+  if (Array.isArray(fieldOrder)) {
+    const fo = fieldOrder.map((f) => highlighter.string(`"${f}"`)).join(', ');
+    str += `${indent}fieldOrder ${highlighter.punctuation('[')}${fo}${highlighter.punctuation(']')}\n`;
+  }
+  return str
+}
+
+function stringpairs (indent, kind, stringpairs, highlighter) {
+  let str = '';
+  if (typeof stringpairs.innerDelim !== 'string') {
+    throw new Error(`Invalid schema, ${kind} stringpairs representations require an innerDelim string`)
+  }
+  if (typeof stringpairs.entryDelim !== 'string') {
+    throw new Error(`Invalid schema, ${kind} stringpairs representations require an entryDelim string`)
+  }
+  str += ` ${highlighter.builtin('representation')} stringpairs ${highlighter.punctuation('{')}\n`;
+  str += `${indent}innerDelim ${highlighter.string(`"${stringpairs.innerDelim}"`)}\n`;
+  str += `${indent}entryDelim ${highlighter.string(`"${stringpairs.entryDelim}"`)}\n`;
+  str += highlighter.punctuation('}');
+  return str
+}
+
+function reprStrategy (defn) {
+  if (typeof defn.representation !== 'object') {
+    throw new Error('Expected \'representation\' property of definition')
+  }
+  const keys = Object.keys(defn.representation);
+  if (keys.length !== 1) {
+    throw new Error('Expected exactly one \'representation\' field')
+  }
+  const repr = keys[0];
+  if (repr === 'advanced') {
+    if (typeof defn.representation[repr] !== 'string') {
+      throw new Error('Expected representation \'advanced\' to be an string')
+    }
+  } else {
+    if (typeof defn.representation[repr] !== 'object') {
+      throw new Error(`Expected representation '${repr}' to be an object`)
+    }
+  }
+  return repr
+}
+
+printTypeTerm.union = function union (defn, indent, highlighter) {
+  if (typeof defn.representation !== 'object') {
+    throw new Error('Invalid schema, unions require a representation')
+  }
+
+  let str = highlighter.punctuation('{');
+  const repr = reprStrategy(defn);
+
+  if (repr === 'kinded') {
+    for (const [kind, type] of Object.entries(defn.representation.kinded)) {
+      str += `\n${indent}${highlighter.punctuation('|')} ${printTypeTerm(type, indent, highlighter)} ${kind}`;
+    }
+    str += `\n${highlighter.punctuation('}')} ${highlighter.builtin('representation')} kinded`;
+  } else if (repr === 'stringprefix' || repr === 'bytesprefix') {
+    if (typeof defn.representation[repr].prefixes !== 'object') {
+      throw new Error(`Invalid schema, ${repr} unions require a representation prefixes map`)
+    }
+    for (const [key, type] of Object.entries(defn.representation[repr].prefixes)) {
+      str += `\n${indent}${highlighter.punctuation('|')} ${printTypeTerm(type, indent, highlighter)} ${highlighter.string(`"${key}"`)}`;
+    }
+    str += `\n${highlighter.punctuation('}')} ${highlighter.builtin('representation')} ${repr}`;
+  } else if (repr === 'keyed') {
+    if (typeof defn.representation[repr] !== 'object') {
+      throw new Error(`Invalid schema, ${repr} unions require a representation keyed map`)
+    }
+    for (const [key, type] of Object.entries(defn.representation[repr])) {
+      str += `\n${indent}${highlighter.punctuation('|')} ${printTypeTerm(type, indent, highlighter)} ${highlighter.string(`"${key}"`)}`;
+    }
+    str += `\n${highlighter.punctuation('}')} ${highlighter.builtin('representation')} ${repr}`;
+  } else if (repr === 'inline') {
+    if (typeof defn.representation.inline.discriminantTable !== 'object') {
+      throw new Error('Invalid schema, inline unions require a discriminantTable map')
+    }
+    if (typeof defn.representation.inline.discriminantKey !== 'string') {
+      throw new Error('Invalid schema, inline unions require a discriminantKey string')
+    }
+    for (const [key, type] of Object.entries(defn.representation.inline.discriminantTable)) {
+      str += `\n${indent}${highlighter.punctuation('|')} ${printTypeTerm(type, indent, highlighter)} ${highlighter.string(`"${key}"`)}`;
+    }
+    str += `\n${highlighter.punctuation('}')} ${highlighter.builtin('representation')} inline ${highlighter.punctuation('{')}\n${indent}discriminantKey ${highlighter.string(`"${defn.representation.inline.discriminantKey}"`)}\n${highlighter.punctuation('}')}`;
+  } else if (repr === 'envelope') {
+    if (typeof defn.representation.envelope.discriminantTable !== 'object') {
+      throw new Error('Invalid schema, envelope unions require a discriminantTable map')
+    }
+    if (typeof defn.representation.envelope.discriminantKey !== 'string') {
+      throw new Error('Invalid schema, envelope unions require a discriminantKey string')
+    }
+    if (typeof defn.representation.envelope.contentKey !== 'string') {
+      throw new Error('Invalid schema, envelope unions require a contentKey string')
+    }
+    for (const [key, type] of Object.entries(defn.representation.envelope.discriminantTable)) {
+      str += `\n${indent}${highlighter.punctuation('|')} ${printTypeTerm(type, indent, highlighter)} ${highlighter.string(`"${key}"`)}`;
+    }
+    str += `\n${highlighter.punctuation('}')} ${highlighter.builtin('representation')} envelope ${highlighter.punctuation('{')}`;
+    str += `\n${indent}discriminantKey ${highlighter.string(`"${defn.representation.envelope.discriminantKey}"`)}`;
+    str += `\n${indent}contentKey ${highlighter.string(`"${defn.representation.envelope.contentKey}"`)}`;
+    str += `\n${highlighter.punctuation('}')}`;
+  } else {
+    throw new Error(`Invalid schema, unknown union representation type ${Object.keys(defn.representation)[0]}`)
+  }
+
+  return str
+};
+
+printTypeTerm.enum = function _enum (defn, indent, highlighter) {
+  if (typeof defn.representation !== 'object') {
+    throw new Error('Invalid schema, enum requires a "representation" map')
+  }
+  const repr = reprStrategy(defn);
+  if (repr !== 'string' && repr !== 'int') {
+    throw new Error('Invalid schema, enum requires a "string" or "int" representation map')
+  }
+
+  let str = highlighter.punctuation('{');
+
+  for (const ev of defn.members) {
+    str += `\n${indent}${highlighter.punctuation('|')} ${ev}`;
+    const sv = (defn.representation.string && defn.representation.string[ev]) ||
+      (defn.representation.int && defn.representation.int[ev]);
+    if (sv !== undefined) {
+      str += ` ${highlighter.punctuation('(')}${highlighter.string(`"${sv}"`)}${highlighter.punctuation(')')}`;
+    }
+  }
+
+  str += `\n${highlighter.punctuation('}')}`;
+  if (defn.representation.int) {
+    str += ` ${highlighter.builtin('representation')} int`;
+  }
+  return str
+};
+
+const DEFAULT_HASHER = sha256$2;
+const DEFAULT_HASH_BYTES = 32;
+// 5/3 seems to offer best perf characteristics in terms of raw speed
+// (Filecoin found this too for their HAMT usage)
+// but amount and size of garbage will change with different parameters
+const DEFAULT_BITWIDTH = 5;
+const DEFAULT_BUCKET_SIZE = 3;
+
+const textDecoder = new TextDecoder();
+
+/**
+ * @template V
+ * @typedef {import('iamap').IAMap<V>} IAMap<V>
+ */
+/**
+ * @template V
+ * @typedef {import('iamap').Store<V>} Store<V>
+ */
+/**
+ * @typedef {import('multiformats/hashes/interface').MultihashHasher} MultihashHasher
+ */
+/**
+ * @template V
+ * @typedef {import('./interface').HashMap<V>} HashMap<V>
+ */
+/**
+ * @template {number} Codec
+ * @template V
+ * @typedef {import('./interface').CreateOptions<Codec,V>} CreateOptions<Codec,V>
+ */
+/**
+ * @typedef {import('./interface').Loader} Loader<V>
+ */
+
+/**
+ * @classdesc
+ * An IPLD HashMap object. Create a new HashMap or load an existing one with the asynchronous
+ * {@link HashMap.create} factory method.
+ *
+ * This class serves mostly as a IPLD usability wrapper for
+ * [IAMap](https://github.com/rvagg/iamap) which implements the majority of the logic behind the
+ * IPLD HashMap specification, without being IPLD-specific. IAMap is immutable, in that each
+ * mutation (delete or set) returns a new IAMap instance. `HashMap`, however, is immutable, and
+ * mutation operations may be performed on the same object but its `cid` property will change
+ * with mutations.
+ *
+ * If consumed with TypeScript typings, `HashMap` is generic over value template type `V`, where various
+ * operations will accept or return template type `V`.
+ *
+ * @name HashMap
+ * @template V
+ * @implements {HashMap<V>}
+ * @class
+ * @hideconstructor
+ * @property {CID} cid - The _current_ CID of this HashMap. It is important to note that this CID
+ * will change when successfully performing mutation operations `set()` or
+ * `delete()`. Where a `set()` does not change an existing value (because
+ * a key already exists with that value) or `delete()` does not delete an existing
+ * key/value pair (because it doesn't already exist in this HashMap), the `cid` will not change.
+ */
+class HashMapImpl {
+  /**
+   * @ignore
+   * @param {IAMap<V>} iamap
+   */
+  constructor (iamap) {
+    // IAMap is immutable, so mutation operations return a new instance so
+    // we use `this._iamap` as the _current_ instance and wrap around that,
+    // switching it out as we mutate
+    this._iamap = iamap;
+  }
+
+  /**
+   * @name HashMap#get
+   * @description
+   * Fetches the value of the provided `key` stored in this HashMap, if it exists.
+   * @function
+   * @async
+   * @memberof HashMap
+   * @param {string|Uint8Array} key - The key of the key/value pair entry to look up in this HashMap.
+   * @return {Promise<V|undefined>}
+   * The value (of template type `V`) stored for the given `key` which may be any type serializable
+   * by IPLD, or a CID to an existing IPLD object. This should match what was provided by
+   * {@link HashMap#set} as the `value` for this `key`. If the `key` is not stored in this HashMap,
+   * `undefined` will be returned.
+   */
+  async get (key) {
+    return this._iamap.get(key)
+  }
+
+  /**
+   * @name HashMap#has
+   * @description
+   * Check whether the provided `key` exists in this HashMap. The equivalent of performing
+   * `map.get(key) !== undefined`.
+   * @function
+   * @async
+   * @memberof HashMap
+   * @param {string|Uint8Array} key - The key of the key/value pair entry to look up in this HashMap.
+   * @return {Promise<boolean>}
+   * `true` if the `key` exists in this HashMap, `false` otherwise.
+   */
+  async has (key) {
+    return this._iamap.has(key)
+  }
+
+  /**
+   * @name HashMap#size
+   * @description
+   * Count the number of key/value pairs stored in this HashMap.
+   * @function
+   * @async
+   * @memberof HashMap
+   * @return {Promise<number>}
+   * An integer greater than or equal to zero indicating the number of key/value pairse stored
+   * in this HashMap.
+   */
+  async size () {
+    return this._iamap.size()
+  }
+
+  /**
+   * @name HashMap#set
+   * @description
+   * Add a key/value pair to this HashMap. The value may be any object that can be serialized by
+   * IPLD, or a CID to a more complex (or larger) object. {@link HashMap#get} operations on the
+   * same `key` will retreve the `value` as it was set as long as serialization and deserialization
+   * results in the same object.
+   *
+   * If the `key` already exists in this HashMap, the existing entry will have the `value` replaced
+   * with the new one provided. If the `value` is the same, the HashMap will remain unchanged.
+   *
+   * As a mutation operation, performing a successful `set()` where a new key/value pair or new
+   * `value` for a given `key` is set, a new root node will be generated so `map.cid` will be a
+   * different CID. This CID should be used to refer to this collection in the backing store where
+   * persistence is required.
+   * @function
+   * @async
+   * @memberof HashMap
+   * @param {string|Uint8Array} key - The key of the new key/value pair entry to store in this HashMap.
+   * @param {V} value - The value (of template type `V`) to store, either an object that can be
+   * serialized inline via IPLD or a CID pointing to another object.
+   * @returns {Promise<void>}
+   */
+  async set (key, value) {
+    this._iamap = await this._iamap.set(key, value);
+  }
+
+  /**
+   * @name HashMap#delete
+   * @description
+   * Remove a key/value pair to this HashMap.
+   *
+   * If the `key` exists in this HashMap, its entry will be entirely removed. If the `key` does not
+   * exist in this HashMap, no changes will occur.
+   *
+   * As a mutation operation, performing a successful `delete()` where an existing key/value pair
+   * is removed from the collection, a new root node will be generated so `map.cid` will be a
+   * different CID. This CID should be used to refer to this collection in the backing store where
+   * persistence is required.
+   * @function
+   * @async
+   * @memberof HashMap
+   * @param {string|Uint8Array} key - The key of the key/value pair entry to remove from this HashMap.
+   * @returns {Promise<void>}
+   */
+  async delete (key) {
+    this._iamap = await this._iamap.delete(key);
+  }
+
+  /**
+   * @name HashMap#values
+   * @description
+   * Asynchronously emit all values that exist within this HashMap collection.
+   *
+   * This will cause a full traversal of all nodes that make up this collection so may result in
+   * many block loads from the backing store if the collection is large.
+   * @function
+   * @async
+   * @returns {AsyncIterable<V>}
+   * An async iterator that yields values (of template type `V`) of the type stored in this
+   * collection, either inlined objects or CIDs.
+   */
+  async * values () {
+    yield * this._iamap.values();
+  }
+
+  /**
+   * @name HashMap#keys
+   * @description
+   * Asynchronously emit all keys that exist within this HashMap collection **as strings** rather
+   * than the stored bytes.
+   *
+   * This will cause a full traversal of all nodes that make up this
+   * collection so may result in many block loads from the backing store if the collection is large.
+   * @function
+   * @async
+   * @returns {AsyncIterable<string>}
+   * An async iterator that yields string keys stored in this collection.
+   */
+  async * keys () {
+    for await (const key of this._iamap.keys()) {
+      // IAMap keys are Uint8Arrays, make them strings
+      yield textDecoder.decode(key);
+    }
+  }
+
+  /**
+   * @name HashMap#keysRaw
+   * @description
+   * Asynchronously emit all keys that exist within this HashMap collection **as their raw bytes**
+   * rather than being converted to a string.
+   *
+   * This will cause a full traversal of all nodes that make up this collection so may result in
+   * many block loads from the backing store if the collection is large.
+   * @function
+   * @async
+   * @returns {AsyncIterable<Uint8Array>}
+   * An async iterator that yields string keys stored in this collection.
+   */
+  async * keysRaw () {
+    yield * this._iamap.keys();
+  }
+
+  /**
+   * @name HashMap#entries
+   * @description
+   * Asynchronously emit all key/value pairs that exist within this HashMap collection. Keys will be
+   * given **as strings** rather than their raw byte form as stored.
+   *
+   * This will cause a full traversal of all nodes that make up this collection so may result in
+   * many block loads from the backing store if the collection is large.
+   *
+   * Entries are returned in tuple form like
+   * [Map#entries()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries),
+   * an array of key/value pairs where element `0` is the key and `1` is the value.
+   * @function
+   * @async
+   * @returns {AsyncIterable<[string, V]>}
+   * An async iterator that yields key/value pair tuples.
+   */
+  async * entries () {
+    for await (const { key, value } of this._iamap.entries()) {
+      // IAMap keys are Uint8Arrays, make them strings
+      yield [textDecoder.decode(key), value];
+    }
+  }
+
+  /**
+   * @name HashMap#entriesRaw
+   * @description
+   * Asynchronously emit all key/value pairs that exist within this HashMap collection. Keys will be
+   * given **as raw bytes** as stored rather than being converted to strings.
+   *
+   * This will cause a full traversal of all nodes that make up this collection so may result in
+   * many block loads from the backing store if the collection is large.
+   *
+   * Entries are returned in tuple form like
+   * [Map#entries()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries),
+   * an array of key/value pairs where element `0` is the key and `1` is the value.
+   * @function
+   * @async
+   * @returns {AsyncIterable<[Uint8Array, V]>}
+   * An async iterator that yields key/value pair tuples.
+   */
+  async * entriesRaw () {
+    for await (const { key, value } of this._iamap.entries()) {
+      yield [key, value];
+    }
+  }
+
+  /**
+   * @name HashMap#cids
+   * @description
+   * Asynchronously emit all CIDs for blocks that make up this HashMap.
+   *
+   * This will cause a full traversal of all nodes that make up this collection so may result in
+   * many block loads from the backing store if the collection is large.
+   * @function
+   * @async
+   * @returns {AsyncIterable<CID>}
+   * An async iterator that yields CIDs for the blocks that comprise this HashMap.
+   */
+  async * cids () {
+    yield * this._iamap.ids();
+  }
+
+  get cid () {
+    return this._iamap.id
+  }
+
+  /**
+   * Create a new {@link HashMap} instance, beginning empty, or loading from existing data in a
+   * backing store.
+   *
+   * A backing store must be provided to make use of a HashMap, an interface to the store is given
+   * through the mandatory `loader` parameter. The backing store stores IPLD blocks, referenced by
+   * CIDs. `loader` must have two functions: `get(cid)` which should return the raw bytes (`Buffer`
+   * or `Uint8Array`) of a block matching the given CID, and `put(cid, block)` that will store the
+   * provided raw bytes of a block (`block`) and store it with the associated CID.
+   *
+   * @async
+   * @template V
+   * @template {number} Codec
+   * @param {Loader} loader - A loader with `get(cid):block` and `put(cid, block)` functions for
+   * loading an storing block data by CID.
+   * @param {CreateOptions<Codec, V>} options - Options for the HashMap. Defaults are provided but you can tweak
+   * behavior according to your needs with these options.
+   * @return {Promise<HashMap<V>>} - A HashMap instance, either loaded from an existing root block CID, or a new,
+   * empty HashMap if no CID is provided.
+   */
+  static async create (loader, options) {
+    return _load(loader, null, options)
+  }
+
+  /**
+   * @template V
+   * @template {number} Codec
+   * @param {Loader} loader
+   * @param {CID} root - A root of an existing HashMap. Provide a CID if you want to load existing
+   * data.
+   * @param {CreateOptions<Codec, V>} options
+   * @returns {Promise<HashMap<V>>}
+   */
+  static async load (loader, root, options) {
+    return _load(loader, root, options)
+  }
+}
+
+/**
+ * @ignore
+ * @template V
+ * @template {number} Codec
+ * @param {Loader} loader
+ * @param {CID|null} root
+ * @param {CreateOptions<Codec, V>} options
+ * @returns {Promise<HashMap<V>>}
+ */
+async function _load (loader, root, options) {
+  const cid = CID$1.asCID(root);
+
+  if (!loader || typeof loader.get !== 'function' || typeof loader.put !== 'function') {
+    throw new TypeError('\'loader\' object with get() and put() methods is required')
+  }
+
+  if (typeof options !== 'object') {
+    throw new TypeError('An \'options\' argument is required')
+  }
+
+  if (!('blockCodec' in options) ||
+      typeof options.blockCodec !== 'object' ||
+      typeof options.blockCodec.code !== 'number' ||
+      typeof options.blockCodec.encode !== 'function' ||
+      typeof options.blockCodec.decode !== 'function') {
+    throw new TypeError('A valid \'blockCodec\' option is required')
+  }
+  const codec = options.blockCodec;
+  if (!('blockHasher' in options) ||
+      typeof options.blockHasher !== 'object' ||
+      typeof options.blockHasher.digest !== 'function' ||
+      typeof options.blockHasher.code !== 'number') {
+    throw new TypeError('A valid \'blockHasher\' option is required')
+  }
+  const hasher = options.blockHasher;
+
+  /**
+   * @ignore
+   * @type {MultihashHasher}
+   */
+  const hamtHasher = (() => {
+    if ('hasher' in options) {
+      if (typeof options.hasher !== 'object' ||
+          typeof options.hasher.digest !== 'function' ||
+          typeof options.hasher.code !== 'number') {
+        throw new TypeError('\'hasher\' option must be a Multihasher')
+      }
+      return options.hasher
+    }
+    return DEFAULT_HASHER
+  })();
+  const hashBytes = (() => {
+    if ('hashBytes' in options) {
+      if (typeof options.hashBytes !== 'number') {
+        throw new TypeError('\'hashBytes\' option must be a number')
+      }
+      /* c8 ignore next 2 */
+      return options.hashBytes
+    }
+    return DEFAULT_HASH_BYTES
+  })();
+  /**
+   * @ignore
+   * @param {Uint8Array} bytes
+   */
+  const hashFn = async (bytes) => {
+    const hash = await sha256$2.digest(bytes);
+    return hash.digest
+  };
+  registerHasher_1(hamtHasher.code, hashBytes, hashFn);
+
+  const bitWidth = (() => {
+    if ('bitWidth' in options) {
+      if (typeof options.bitWidth !== 'number') {
+        throw new TypeError('\'bitWidth\' option must be a number')
+      }
+      return options.bitWidth
+    }
+    return DEFAULT_BITWIDTH
+  })();
+
+  const bucketSize = (() => {
+    if ('bucketSize' in options) {
+      if (typeof options.bucketSize !== 'number') {
+        throw new TypeError('\'bucketSize\' option must be a number')
+      }
+      return options.bucketSize
+    }
+    return DEFAULT_BUCKET_SIZE
+  })();
+
+  const iamapOptions = { hashAlg: hamtHasher.code, bitWidth, bucketSize };
+
+  const store = {
+    /**
+     * @ignore
+     * @param {CID} cid
+     * @returns {Promise<V>}
+     */
+    async load (cid) {
+      const bytes = await loader.get(cid);
+      if (!bytes) {
+        throw new Error(`Could not load block for: ${cid}`)
+      }
+      // create() validates the block for us
+      const block = await create$7({ bytes, cid, hasher, codec });
+      validateBlock(block.value);
+      return block.value
+    },
+
+    /**
+     * @ignore
+     * @param {V} value
+     * @returns {Promise<CID>}
+     */
+    async save (value) {
+      validateBlock(value);
+      const block = await encode$7({ value, codec, hasher });
+      await loader.put(block.cid, block.bytes);
+      return block.cid
+    },
+
+    /**
+     * @ignore
+     * @param {CID} cid1
+     * @param {CID} cid2
+     * @returns {boolean}
+     */
+    isEqual (cid1, cid2) {
+      return cid1.equals(cid2)
+    },
+
+    /**
+     * @ignore
+     * @param {any} obj
+     * @returns {boolean}
+     */
+    isLink (obj) {
+      return CID$1.asCID(obj) != null
+    }
+  };
+
+  let iamap;
+  if (cid) {
+    // load existing, ignoring bitWidth & bucketSize, they are loaded from the existing root
+    iamap = await load_1(store, cid);
+  } else {
+    // create new
+    iamap = await create_1(store, iamapOptions);
+  }
+
+  return new HashMapImpl(iamap)
+}
+
+/**
+ * @ignore
+ * @param {any} block
+ */
+function validateBlock (block) {
+  if (!HashMapNode(block) && !HashMapRoot(block)) {
+    const description = print(describe(block).schema);
+    throw new Error(`Internal error: unexpected layout for HashMap block does not match schema, got:\n${description}`)
+  }
+}
+
+const create$1 = HashMapImpl.create;
+const load$1 = HashMapImpl.load;
+
+// @ts-nocheck
+// from https://github.com/duzun/sync-sha1/blob/master/rawSha1.js
+// MIT License Copyright (c) 2020 Dumitru Uzun
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// import {
+//   isLittleEndian, switchEndianness32
+// } from 'string-encode'
+
+/**
+* SHA1 on binary array
+*
+* @param   {Uint8Array}  b  Data to hash
+*
+* @return  {Uint8Array}  sha1 hash
+*/
+function rawSha1 (b) {
+  let i = b.byteLength;
+  let bs = 0;
+  let A; let B; let C; let D; let G;
+  const H = Uint32Array.from([A = 0x67452301, B = 0xEFCDAB89, ~A, ~B, 0xC3D2E1F0]);
+  const W = new Uint32Array(80);
+  const nrWords = (i / 4 + 2) | 15;
+  const words = new Uint32Array(nrWords + 1);
+  let j;
+
+  words[nrWords] = i * 8;
+  words[i >> 2] |= 0x80 << (~i << 3);
+  for (;i--;) {
+    words[i >> 2] |= b[i] << (~i << 3);
+  }
+
+  for (A = H.slice(); bs < nrWords; bs += 16, A.set(H)) {
+    for (i = 0; i < 80;
+      A[0] = (
+        G = ((b = A[0]) << 5 | b >>> 27) +
+                  A[4] +
+                  (W[i] = (i < 16) ? words[bs + i] : G << 1 | G >>> 31) +
+                  0x5A827999,
+        B = A[1],
+        C = A[2],
+        D = A[3],
+        G + ((j = i / 5 >> 2) // eslint-disable-line no-cond-assign
+          ? j !== 2
+            ? (B ^ C ^ D) + (j & 2 ? 0x6FE0483D : 0x14577208)
+            : (B & C | B & D | C & D) + 0x34994343
+          : B & C | ~B & D
+        )
+      )
+      , A[1] = b
+      , A[2] = B << 30 | B >>> 2
+      , A[3] = C
+      , A[4] = D
+      , ++i
+    ) {
+      G = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+    }
+
+    for (i = 5; i;) H[--i] = H[i] + A[i];
+  }
+
+  // if (isLittleEndian()) {
+  //   H = H.map(switchEndianness32)
+  // }
+
+  return new Uint8Array(H.buffer, H.byteOffset, H.byteLength)
+}
+
+const chunker = bf(30);
+
+const blockOpts$1 = { cache: nocache, chunker, codec: codec$1, hasher: sha256$2, compare: simpleCompare };
+
+const NO_ENCRYPT = typeof process !== 'undefined' && !!process.env?.NO_ENCRYPT;
+// ? process.env.NO_ENCRYPT : import.meta && import.meta.env.VITE_NO_ENCRYPT
+
+class Valet {
+  idb = null
+  name = null
+  uploadQueue = null
+  alreadyEnqueued = new Set()
+  keyMaterial = null
+  keyId = 'null'
+  valetRoot = null
+  valetRootCid = null // set by hydrate
+  valetRootCarCid = null // most recent diff
+
+  valetCidBlocks = new VMemoryBlockstore()
+  instanceId = Math.random().toString(36).slice(2)
+
+  /**
+   * Function installed by the database to upload car files
+   * @type {null|function(string, Uint8Array):Promise<void>}
+   */
+  uploadFunction = null
+
+  constructor (name = 'default', keyMaterial) {
+    this.name = name;
+    this.setKeyMaterial(keyMaterial);
+    this.uploadQueue = cargoQueue(async (tasks, callback) => {
+      // console.log(
+      //   'queue worker',
+      //   tasks.length,
+      //   tasks.reduce((acc, t) => acc + t.value.length, 0)
+      // )
+      if (this.uploadFunction) {
+        // todo we can coalesce these into a single car file
+        return await this.withDB(async db => {
+          for (const task of tasks) {
+            await this.uploadFunction(task.carCid, task.value);
+            // update the indexedb to mark this car as no longer pending
+            const carMeta = await db.get('cidToCar', task.carCid);
+            delete carMeta.pending;
+            await db.put('cidToCar', carMeta);
+          }
+        })
+      }
+      callback();
+    });
+
+    this.uploadQueue.drain(async () => {
+      return await this.withDB(async db => {
+        const carKeys = (await db.getAllFromIndex('cidToCar', 'pending')).map(c => c.car);
+        for (const carKey of carKeys) {
+          await this.uploadFunction(carKey, await db.get('cars', carKey));
+          const carMeta = await db.get('cidToCar', carKey);
+          delete carMeta.pending;
+          await db.put('cidToCar', carMeta);
+        }
+      })
+    });
+  }
+
+  getKeyMaterial () {
+    return this.keyMaterial
+  }
+
+  setKeyMaterial (km) {
+    if (km && !NO_ENCRYPT) {
+      const hex = Uint8Array.from(Buffer$G.from(km, 'hex'));
+      this.keyMaterial = km;
+      const hash = rawSha1(hex);
+      this.keyId = Buffer$G.from(hash).toString('hex');
+    } else {
+      this.keyMaterial = null;
+      this.keyId = 'null';
+    }
+    // console.trace('keyId', this.name, this.keyId)
+  }
+
+  /**
+   * Group the blocks into a car and write it to the valet.
+   * @param {import('./blockstore.js').InnerBlockstore} innerBlockstore
+   * @param {Set<string>} cids
+   * @returns {Promise<void>}
+   * @memberof Valet
+   */
+  async writeTransaction (innerBlockstore, cids) {
+    if (innerBlockstore.lastCid) {
+      if (this.keyMaterial) {
+        // console.log('encrypting car', innerBlockstore.label)
+        // should we pass cids in instead of iterating frin innerBlockstore?
+        const newCar = await blocksToEncryptedCarBlock(innerBlockstore.lastCid, innerBlockstore, this.keyMaterial);
+        await this.parkCar(newCar.cid.toString(), newCar.bytes, cids);
+      } else {
+        const newCar = await blocksToCarBlock(innerBlockstore.lastCid, innerBlockstore);
+        await this.parkCar(newCar.cid.toString(), newCar.bytes, cids);
+      }
+    } else {
+      throw new Error('missing lastCid for car header')
+    }
+  }
+
+  withDB = async dbWorkFun => {
+    if (!this.idb) {
+      this.idb = await openDB(`fp.${this.keyId}.${this.name}.valet`, 2, {
+        upgrade (db, oldVersion, newVersion, transaction) {
+          if (oldVersion < 1) {
+            db.createObjectStore('cars'); // todo use database name
+            const cidToCar = db.createObjectStore('cidToCar', { keyPath: 'car' });
+            cidToCar.createIndex('cids', 'cids', { multiEntry: true });
+          }
+          if (oldVersion < 2) {
+            const cidToCar = transaction.objectStore('cidToCar');
+            cidToCar.createIndex('pending', 'pending');
+          }
+        }
+      });
+    }
+    return await dbWorkFun(this.idb)
+  }
+
+  /**
+   * Iterate over all blocks in the store.
+   *
+   * @yields {{cid: string, value: Uint8Array}}
+   * @returns {AsyncGenerator<any, any, any>}
+   */
+  async * cids () {
+    // console.log('valet cids')
+    const db = await this.withDB(async db => db);
+    const tx = db.transaction(['cidToCar'], 'readonly');
+    let cursor = await tx.store.openCursor();
+    while (cursor) {
+      yield { cid: cursor.key, car: cursor.value.car };
+      cursor = await cursor.continue();
+    }
+  }
+
+  setRootCarCid (cid) {
+    this.valetRootCarCid = cid;
+    this.valetRoot = null;
+    this.valetRootCid = null;
+  }
+
+  async getCarCIDForCID (cid) {
+    // make a car reader for this.valetRootCarCid
+    if (!this.valetRootCarCid) return
+
+    let indexNode;
+    if (this.valetRoot) {
+      indexNode = this.valetRoot;
+    } else {
+      const combinedReader = await this.getCombinedReader(this.valetRootCarCid);
+      if (!this.valetRootCid) {
+        const root = combinedReader.root.cid;
+        // console.log('roots', this.instanceId, this.name, root, this.valetRootCarCid, this.valetRootCid)
+        this.valetRootCid = root;
+      }
+      indexNode = await load$1(combinedReader, this.valetRootCid, {
+        blockHasher: blockOpts$1.hasher,
+        blockCodec: blockOpts$1.codec
+      });
+    }
+
+    const got = await indexNode.get(cid);
+    // console.log('getCarCIDForCID', cid, got)
+    return { result: got }
+  }
+
+  async OLDgetCarCIDForCID (cid) {
+    const carCid = await this.withDB(async db => {
+      const tx = db.transaction(['cars', 'cidToCar'], 'readonly');
+      const indexResp = await tx.objectStore('cidToCar').index('cids').get(cid);
+      return indexResp?.car
+    });
+    return { result: carCid }
+  }
+
+  async getCombinedReader (carCid) {
+    let carMapReader;
+    if (this.valetRootCarCid) {
+      // todo only need this if we are cold starting
+      carMapReader = await this.getCarReader(this.valetRootCarCid);
+    }
+
+    const theseValetCidBlocks = this.valetCidBlocks;
+    // console.log('theseValetCidBlocks', theseValetCidBlocks)
+    const combinedReader = {
+      root: carMapReader?.root,
+      put: async (cid, bytes) => {
+        // console.log('mapPut', cid, bytes.length)
+        return await theseValetCidBlocks.put(cid, bytes)
+      },
+      get: async cid => {
+        // console.log('mapGet', cid)
+        try {
+          const got = await theseValetCidBlocks.get(cid);
+          return got.bytes
+        } catch (e) {
+          // console.log('get from car', cid, carMapReader)
+          if (!carMapReader) throw e
+          const bytes = await carMapReader.get(cid);
+          await theseValetCidBlocks.put(cid, bytes);
+          // console.log('mapGet', cid, bytes.length, bytes.constructor.name)
+          return bytes
+        }
+      }
+    };
+    return combinedReader
+  }
+
+  /**
+   *
+   * @param {string} carCid
+   * @param {*} value
+   */
+  async parkCar (carCid, value, cids) {
+    // console.log('parkCar', this.instanceId, this.name, carCid, cids)
+    const combinedReader = await this.getCombinedReader(carCid);
+    const mapNode = await addCidsToCarIndex(
+      combinedReader,
+      this.valetRoot,
+      this.valetRootCid,
+      Array.from(cids).map(cid => ({ key: cid.toString(), value: carCid.toString() }))
+    );
+
+    this.valetRoot = mapNode;
+    this.valetRootCid = mapNode.cid;
+    // make a block set with all the cids of the map
+    const saveValetBlocks = new VMemoryBlockstore(); //  todo this blockstore should read from the last valetCid car also
+
+    for await (const cidx of mapNode.cids()) {
+      const bytes = await combinedReader.get(cidx);
+      saveValetBlocks.put(cidx, bytes);
+    }
+    let newValetCidCar;
+    if (this.keyMaterial) {
+      newValetCidCar = await blocksToEncryptedCarBlock(this.valetRootCid, saveValetBlocks, this.keyMaterial);
+    } else {
+      newValetCidCar = await blocksToCarBlock(this.valetRootCid, saveValetBlocks);
+    }
+    // console.log('newValetCidCar', this.name, Math.floor(newValetCidCar.bytes.length / 1024))
+    await this.withDB(async db => {
+      const tx = db.transaction(['cars'], 'readwrite');
+      await tx.objectStore('cars').put(value, carCid.toString());
+      if (newValetCidCar) {
+        if (this.valetRootCarCid) ;
+        await tx.objectStore('cars').put(newValetCidCar.bytes, newValetCidCar.cid.toString());
+      }
+      return await tx.done
+    });
+    this.valetRootCarCid = newValetCidCar.cid; // goes to clock
+
+    // console.log('parked car', carCid, value.length, Array.from(cids))
+    // upload to web3.storage if we have credentials
+    if (this.uploadFunction) {
+      if (this.alreadyEnqueued.has(carCid)) {
+        // console.log('already enqueued', carCid)
+        return
+      }
+      // don't await this, it will be done in the queue
+      // console.log('add to queue', carCid, value.length)
+      this.uploadQueue.push({ carCid, value });
+      this.alreadyEnqueued.add(carCid);
+    }
+  }
+
+  remoteBlockFunction = null
+
+  async getCarReader (carCid) {
+    carCid = carCid.toString();
+    const carBytes = await this.withDB(async db => {
+      const tx = db.transaction(['cars'], 'readonly');
+      // console.log('getCarReader', carCid)
+      return await tx.objectStore('cars').get(carCid)
+    });
+    const reader = await CarReader.fromBytes(carBytes);
+    if (this.keyMaterial) {
+      const roots = await reader.getRoots();
+      const readerGetWithCodec = async cid => {
+        const got = await reader.get(cid);
+        // console.log('got.', cid.toString())
+        let useCodec = codec;
+        if (cid.toString().indexOf('bafy') === 0) {
+          // todo cleanup types
+          useCodec = codec$1;
+        }
+        const decoded = await decode$9({
+          ...got,
+          codec: useCodec,
+          hasher: sha256$2
+        });
+        // console.log('decoded', decoded.value)
+        return decoded
+      };
+      const { blocks } = await blocksFromEncryptedCarBlock(roots[0], readerGetWithCodec, this.keyMaterial);
+
+      // last block is the root ???
+      const rootBlock = blocks[blocks.length - 1];
+
+      return {
+        root: rootBlock,
+        get: async dataCID => {
+          // console.log('getCarReader dataCID', dataCID)
+          dataCID = dataCID.toString();
+          const block = blocks.find(b => b.cid.toString() === dataCID);
+          // console.log('getCarReader block', block)
+          if (block) {
+            return block.bytes
+          }
+        }
+      }
+    } else {
+      return {
+        root: reader.getRoots()[0],
+        get: async dataCID => {
+          const gotBlock = await reader.get(CID$1.parse(dataCID));
+          if (gotBlock) {
+            return gotBlock.bytes
+          }
+        }
+      }
+    }
+  }
+
+  // todo memoize this
+  async getValetBlock (dataCID) {
+    // console.log('get valet block', dataCID)
+    const { result: carCid } = await this.getCarCIDForCID(dataCID);
+    if (!carCid) {
+      throw new Error('Missing block: ' + dataCID)
+    }
+    const reader = await this.getCarReader(carCid);
+    return await reader.get(dataCID)
+  }
+}
+
+const blocksToCarBlock = async (rootCids, blocks) => {
+  // console.log('blocksToCarBlock', rootCids, blocks.constructor.name)
+  let size = 0;
+  if (!Array.isArray(rootCids)) {
+    rootCids = [rootCids];
+  }
+  const headerSize = headerLength({ roots: rootCids });
+  size += headerSize;
+  if (!Array.isArray(blocks)) {
+    blocks = Array.from(blocks.entries());
+  }
+  for (const { cid, bytes } of blocks) {
+    // console.log(cid, bytes)
+    size += blockLength({ cid, bytes });
+  }
+  const buffer = new Uint8Array(size);
+  const writer = await createWriter(buffer, { headerSize });
+
+  for (const cid of rootCids) {
+    writer.addRoot(cid);
+  }
+
+  for (const { cid, bytes } of blocks) {
+    writer.write({ cid, bytes });
+  }
+  await writer.close();
+  return await encode$7({ value: writer.bytes, hasher: sha256$2, codec: raw })
+};
+
+const blocksToEncryptedCarBlock = async (innerBlockStoreClockRootCid, blocks, keyMaterial) => {
   const encryptionKey = Buffer$G.from(keyMaterial, 'hex');
   const encryptedBlocks = [];
   const theCids = [];
@@ -37334,6 +39942,58 @@ const blocksFromEncryptedCarBlock = async (cid, get, keyMaterial) => {
   }
 };
 
+const addCidsToCarIndex = async (blockstore, valetRoot, valetRootCid, bulkOperations) => {
+  let indexNode;
+  if (valetRootCid) {
+    if (valetRoot) {
+      indexNode = valetRoot;
+    } else {
+      indexNode = await load$1(blockstore, valetRootCid, { blockHasher: blockOpts$1.hasher, blockCodec: blockOpts$1.codec });
+    }
+  } else {
+    indexNode = await create$1(blockstore, {
+      bitWidth: 4,
+      bucketSize: 2,
+      blockHasher: blockOpts$1.hasher,
+      blockCodec: blockOpts$1.codec
+    });
+  }
+  // console.log('adding', bulkOperations.length, 'cids to index')
+  for (const { key, value } of bulkOperations) {
+    // console.log('adding', key, value)
+    await indexNode.set(key, value);
+  }
+  return indexNode
+};
+
+class VMemoryBlockstore {
+  /** @type {Map<string, Uint8Array>} */
+  blocks = new Map()
+  instanceId = Math.random().toString(36).slice(2)
+
+  async get (cid) {
+    const bytes = this.blocks.get(cid.toString());
+    // console.log('getvm', bytes.constructor.name, this.instanceId, cid, bytes && bytes.length)
+    if (bytes.length === 253) ;
+    if (!bytes) throw new Error('block not found ' + cid.toString())
+    return { cid, bytes }
+  }
+
+  /**
+   * @param {import('../src/link').AnyLink} cid
+   * @param {Uint8Array} bytes
+   */
+  async put (cid, bytes) {
+    this.blocks.set(cid.toString(), bytes);
+  }
+
+  * entries () {
+    for (const [str, bytes] of this.blocks) {
+      yield { cid: parse(str), bytes };
+    }
+  }
+}
+
 // const sleep = ms => new Promise(r => setTimeout(r, ms))
 
 const husherMap = new Map();
@@ -37412,7 +40072,7 @@ class TransactionBlockstore {
     // console.log('committedGet: ' + key + ' ' + this.instanceId, old.length)
     if (old) return old
     if (!this.valet) throw new Error('Missing block: ' + key)
-    const got = await this.valet.getBlock(key);
+    const got = await this.valet.getValetBlock(key);
     this.committedBlocks.set(key, got);
     return got
   }
@@ -37627,7 +40287,7 @@ const makeGetBlock = blocks => {
     // const { cid, bytes } = await withLog(address, () => blocks.get(address))
     const { cid, bytes } = await blocks.get(address);
     // cids.add({ address: cid })
-    return create$5({ cid, bytes, hasher: sha256$2, codec: codec$1 })
+    return create$7({ cid, bytes, hasher: sha256$2, codec: codec$1 })
   };
   return {
     // cids,
@@ -37754,7 +40414,7 @@ const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
   const event = await events.get(ancestor);
   const { root } = event.value.data;
   if (root) {
-    return load$2({ cid: root, get: getBlock, ...blockOpts })
+    return load$4({ cid: root, get: getBlock, ...blockOpts })
   } else {
     // console.log('no root', root) // false means no common ancestor. null means empty database.
     return root
@@ -37808,7 +40468,7 @@ const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
     if (bulkOperations.every(op => op.del)) {
       return { root: null, blocks: [], clockCIDs: await events.all() }
     }
-    for await (const node of create$3({ get: getBlock, list: bulkOperations, ...blockOpts })) {
+    for await (const node of create$5({ get: getBlock, list: bulkOperations, ...blockOpts })) {
       // root = await node.block
       root = node;
       newBlocks.push(await node.block);
@@ -38006,7 +40666,7 @@ async function visMerkleTree (blocks, head) {
   // if (!head) return
   if (head && !Array.isArray(head)) {
     const getBl = makeGetBlock(blocks);
-    const prollyRootNode = await load$2({
+    const prollyRootNode = await load$4({
       cid: head,
       get: getBl.getBlock,
       ...blockOpts
@@ -38290,7 +40950,6 @@ const parseCID = cid => (typeof cid === 'string' ? CID$1.parse(cid) : cid);
  *  This is the main class for saving and loading JSON and other documents with the database. You can find additional examples and
  *  usage guides in the repository README.
  *
- * @param {import('./blockstore.js').TransactionBlockstore} blocks - The block storage instance to use documents and indexes
  * @param {CID[]} clock - The Merkle clock head to use for the Fireproof instance.
  * @param {object} [config] - Optional configuration options for the Fireproof instance.
  * @param {object} [authCtx] - Optional authorization context object to use for any authentication checks.
@@ -38302,10 +40961,11 @@ class Database {
   rootCache = null
   eventsCache = new Map()
 
-  constructor (blocks, clock, config = {}) {
-    this.name = config.name;
+  constructor (name, clock, config = {}) {
+    this.name = name;
     this.instanceId = `fp.${this.name}.${Math.random().toString(36).substring(2, 7)}`;
-    this.blocks = blocks;
+    this.blocks = new TransactionBlockstore(name, config.key);
+    this.indexBlocks = new TransactionBlockstore(name + '.indexes', config.key);
     this.clock = clock;
     this.config = config;
   }
@@ -38322,6 +40982,8 @@ class Database {
       clock: this.clockToJSON(),
       name: this.name,
       key: this.blocks.valet?.getKeyMaterial(),
+      car: this.blocks.valet?.valetRootCarCid.toString(),
+      indexCar: this.indexBlocks.valet?.valetRootCarCid?.toString(),
       indexes: [...this.indexes.values()].map(index => index.toJSON())
     }
   }
@@ -38336,11 +40998,14 @@ class Database {
     return (clock || this.clock).map(cid => cid.toString())
   }
 
-  hydrate ({ clock, name, key }) {
+  hydrate ({ clock, name, key, car, indexCar }) {
     this.name = name;
     this.clock = clock;
     this.blocks.valet?.setKeyMaterial(key);
-    this.indexBlocks = null;
+    this.blocks.valet?.setRootCarCid(car); // maybe
+    this.indexBlocks.valet?.setKeyMaterial(key);
+    this.indexBlocks.valet?.setRootCarCid(indexCar); // maybe
+    // this.indexBlocks = null
   }
 
   maybeSaveClock () {
@@ -38379,7 +41044,7 @@ class Database {
     let rows, dataCIDs, clockCIDs;
     // if (!aClock) aClock = []
     if (aClock && aClock.length > 0) {
-      aClock = aClock.map((cid) => cid.toString());
+      aClock = aClock.map(cid => cid.toString());
       const eventKey = JSON.stringify([...this.clockToJSON(aClock), ...this.clockToJSON()]);
 
       let resp;
@@ -38547,6 +41212,7 @@ class Database {
    * @returns {Promise<{ proof:{}, id: string, clock: CID[] }>} - The result of adding the event to storage
    */
   async putToProllyTree (decodedEvent, clock = null) {
+    // console.log('putToProllyTree', decodedEvent)
     const event = encodeEvent(decodedEvent);
     if (clock && JSON.stringify(this.clockToJSON(clock)) !== JSON.stringify(this.clockToJSON())) {
       // console.log('this.clock', this.clockToJSON())
@@ -38664,7 +41330,9 @@ class Database {
 
 async function cidsToProof (cids) {
   if (!cids) return []
-  if (!cids.all) { return [...cids] }
+  if (!cids.all) {
+    return [...cids]
+  }
 
   const all = await cids.all();
   return [...all].map(cid => cid.toString())
@@ -38914,14 +41582,14 @@ const create = opts => {
     ...defaults,
     ...opts
   };
-  return create$3(opts);
+  return create$5(opts);
 };
 const load = opts => {
   opts = {
     ...defaults,
     ...opts
   };
-  return load$2(opts);
+  return load$4(opts);
 };
 
 // @ts-ignore
@@ -38976,21 +41644,21 @@ const makeDoc = ({ key, value }) => ({ _id: key, ...value });
  */
 const indexEntriesForChanges = (changes, mapFn) => {
   const indexEntries = [];
-  changes.forEach(({ key, value, del }) => {
+  changes.forEach(({ key: _id, value, del }) => {
     // key is _id, value is the document
     if (del || !value) return
     let mapCalled = false;
-    const mapReturn = mapFn(makeDoc({ key, value }), (k, v) => {
+    const mapReturn = mapFn(makeDoc({ key: _id, value }), (k, v) => {
       mapCalled = true;
       if (typeof k === 'undefined') return
       indexEntries.push({
-        key: [charwise.encode(k), key],
+        key: [charwise.encode(k), _id],
         value: v || null
       });
     });
     if (!mapCalled && mapReturn) {
       indexEntries.push({
-        key: [charwise.encode(mapReturn), key],
+        key: [charwise.encode(mapReturn), _id],
         value: null
       });
     }
@@ -39014,12 +41682,6 @@ class DbIndex {
    */
   constructor (database, name, mapFn, clock = null, opts = {}) {
     this.database = database;
-    if (!database.indexBlocks) {
-      database.indexBlocks = new TransactionBlockstore(
-        database?.name + '.indexes',
-        database.blocks.valet?.getKeyMaterial()
-      );
-    }
     if (typeof name === 'function') {
       // app is using deprecated API, remove in 0.7
       opts = clock || {};
@@ -39172,7 +41834,14 @@ class DbIndex {
     await loadIndex(this.database.indexBlocks, this.indexByKey, dbIndexOpts);
     if (!this.indexByKey.root) return { result: [] }
     if (query.includeDocs === undefined) query.includeDocs = this.includeDocsDefault;
-    if (query.range) {
+    if (query.prefix) {
+      // ensure prefix is an array
+      if (!Array.isArray(query.prefix)) query.prefix = [query.prefix];
+      const start = [...query.prefix, NaN];
+      const end = [...query.prefix, Infinity];
+      const prefixRange = [start, end].map(key => charwise.encode(key));
+      return await this.applyQuery(await this.indexByKey.root.range(...prefixRange), query)
+    } else if (query.range) {
       const encodedRange = query.range.map(key => charwise.encode(key));
       return await this.applyQuery(await this.indexByKey.root.range(...encodedRange), query)
     } else if (query.key) {
@@ -41339,7 +44008,7 @@ class Sync {
   destroy () {
     this.database.blocks.syncs.delete(this);
     this.status = 'destroyed';
-    this.peer.destroy();
+    // this.peer.destroy()  todo
   }
 
   async sendUpdate (blockstore) {
@@ -41430,22 +44099,29 @@ class Fireproof {
   static storage = (name = null, opts = {}) => {
     if (name) {
       opts.name = name;
+      // todo this can come from a registry also
       const existing = localGet('fp.' + name);
       if (existing) {
         const existingConfig = JSON.parse(existing);
-        const fp = new Database(new TransactionBlockstore(name, existingConfig.key), [], opts);
-        return Fireproof.fromJSON(existingConfig, fp)
+        return Fireproof.fromConfig(name, existingConfig, opts)
       } else {
         const instanceKey = browserExports$1(32).toString('hex'); // pass null to disable encryption
-        return new Database(new TransactionBlockstore(name, instanceKey), [], opts)
+        opts.key = instanceKey;
+        return new Database(name, [], opts)
       }
     } else {
-      return new Database(new TransactionBlockstore(), [], opts)
+      return new Database(null, [], opts)
     }
   }
 
+  static fromConfig (name, existingConfig, opts = {}) {
+    opts.key = existingConfig.key;
+    const fp = new Database(name, [], opts);
+    return Fireproof.fromJSON(existingConfig, fp)
+  }
+
   static fromJSON (json, database) {
-    database.hydrate({ clock: json.clock.map(c => parseCID(c)), name: json.name, key: json.key });
+    database.hydrate({ car: json.car, indexCar: json.indexCar, clock: json.clock.map(c => parseCID(c)), name: json.name, key: json.key });
     if (json.indexes) {
       for (const {
         name,
@@ -41468,7 +44144,8 @@ class Fireproof {
 
   static snapshot (database, clock) {
     const definition = database.toJSON();
-    const withBlocks = new Database(database.blocks);
+    const withBlocks = new Database(database.name);
+    withBlocks.blocks = database.blocks;
     if (clock) {
       definition.clock = clock.map(c => parseCID(c));
       definition.indexes.forEach(index => {