@fireproof/core 0.5.7 → 0.5.9

package/dist/src/fireproof.js

@@ -34,17 +34,9 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
-var browserExports$1 = {};
-var browser$d = {
-  get exports(){ return browserExports$1; },
-  set exports(v){ browserExports$1 = v; },
-};
+var browser$d = {exports: {}};
 
-var safeBufferExports = {};
-var safeBuffer$1 = {
-  get exports(){ return safeBufferExports; },
-  set exports(v){ safeBufferExports = v; },
-};
+var safeBuffer$1 = {exports: {}};
 
 var global$1 = (typeof global !== "undefined" ? global :
   typeof self !== "undefined" ? self :
@@ -2109,8 +2101,10 @@ var require$$6$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_buffer);
 	    throw new TypeError('Argument must be a number')
 	  }
 	  return buffer.SlowBuffer(size)
-	};
-} (safeBuffer$1, safeBufferExports));
+	}; 
+} (safeBuffer$1, safeBuffer$1.exports));
+
+var safeBufferExports = safeBuffer$1.exports;
 
 // limit of Crypto.getRandomValues()
 // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
@@ -2161,6 +2155,9 @@ function randomBytes$2 (size, cb) {
   return bytes
 }
 
+var browserExports$1 = browser$d.exports;
+var randomBytes$3 = /*@__PURE__*/getDefaultExportFromCjs(browserExports$1);
+
 var encode_1$2 = encode$9;
 
 var MSB$4 = 0x80
@@ -2243,13 +2240,13 @@ var length$2 = function (value) {
   )
 };
 
-var varint$2 = {
+var varint$3 = {
     encode: encode_1$2
   , decode: decode$d
   , encodingLength: length$2
 };
 
-var _brrp_varint$1 = varint$2;
+var _brrp_varint$1 = varint$3;
 
 /**
  * @param {Uint8Array} data
@@ -5668,7 +5665,11 @@ async function contains (events, a, b) {
  */
 async function * vis$1 (blocks, head, options = {}) {
   // @ts-ignore
-  const renderNodeLabel = options.renderNodeLabel ?? ((b) => b.value.data.value);
+  const renderNodeLabel = options.renderNodeLabel ?? ((b) => {
+    // @ts-ignore
+    const { key, root, type } = b.value.data;
+    return b.cid.toString() + '\n' + JSON.stringify({ key, root: root.cid.toString(), type }, null, 2).replace(/"/g, '\'')
+  });
   const events = new EventFetcher(blocks);
   yield 'digraph clock {';
   yield '  node [shape=point fontname="Courier"]; head;';
@@ -5709,6 +5710,7 @@ async function findEventsToSync (blocks, head) {
   // console.time(callTag + '.contains')
   const toSync = await asyncFilter(sorted, async (uks) => !(await contains(events, ancestor, uks.cid)));
   // console.timeEnd(callTag + '.contains')
+  // console.log('toSync.contains', toSync.length)
 
   return { cids: events, events: toSync }
 }
@@ -5716,17 +5718,21 @@ async function findEventsToSync (blocks, head) {
 const asyncFilter = async (arr, predicate) =>
   Promise.all(arr.map(predicate)).then((results) => arr.filter((_v, index) => results[index]));
 
-async function findCommonAncestorWithSortedEvents (events, children) {
+async function findCommonAncestorWithSortedEvents (events, children, doFull = false) {
+  // console.trace('findCommonAncestorWithSortedEvents')
   // const callTag = Math.random().toString(36).substring(7)
+  // console.log(callTag + '.children', children.map((c) => c.toString()))
   // console.time(callTag + '.findCommonAncestor')
   const ancestor = await findCommonAncestor(events, children);
   // console.timeEnd(callTag + '.findCommonAncestor')
+  // console.log('ancestor', ancestor.toString())
   if (!ancestor) {
     throw new Error('failed to find common ancestor event')
   }
   // console.time(callTag + '.findSortedEvents')
-  const sorted = await findSortedEvents(events, children, ancestor);
+  const sorted = await findSortedEvents(events, children, ancestor, doFull);
   // console.timeEnd(callTag + '.findSortedEvents')
+  // console.log('sorted', sorted.length)
   return { ancestor, sorted }
 }
 
@@ -5739,6 +5745,7 @@ async function findCommonAncestorWithSortedEvents (events, children) {
  */
 async function findCommonAncestor (events, children) {
   if (!children.length) return
+  if (children.length === 1) return children[0]
   const candidates = children.map((c) => [c]);
   while (true) {
     let changed = false;
@@ -5759,7 +5766,7 @@ async function findCommonAncestor (events, children) {
  * @param {import('./clock').EventLink<EventData>} root
  */
 async function findAncestorCandidate (events, root) {
-  const { value: event } = await events.get(root);
+  const { value: event } = await events.get(root);// .catch(() => ({ value: { parents: [] } }))
   if (!event.parents.length) return root
   return event.parents.length === 1 ? event.parents[0] : findCommonAncestor(events, event.parents)
 }
@@ -5769,6 +5776,7 @@ async function findAncestorCandidate (events, root) {
  * @param  {Array<T[]>} arrays
  */
 function findCommonString (arrays) {
+  // console.log('findCommonString', arrays.map((a) => a.map((i) => String(i))))
   arrays = arrays.map((a) => [...a]);
   for (const arr of arrays) {
     for (const item of arr) {
@@ -5786,15 +5794,33 @@ function findCommonString (arrays) {
 /**
  * Find and sort events between the head(s) and the tail.
  * @param {import('./clock').EventFetcher} events
- * @param {import('./clock').EventLink<EventData>[]} head
+ * @param {any[]} head
  * @param {import('./clock').EventLink<EventData>} tail
  */
-async function findSortedEvents (events, head, tail) {
+async function findSortedEvents (events, head, tail, doFull) {
   // const callTag = Math.random().toString(36).substring(7)
   // get weighted events - heavier events happened first
+  // const callTag = Math.random().toString(36).substring(7)
+
   /** @type {Map<string, { event: import('./clock').EventBlockView<EventData>, weight: number }>} */
   const weights = new Map();
+  head = [...new Set([...head.map((h) => h.toString())])];
+  // console.log(callTag + '.head', head.length)
+
+  const allEvents = new Set([tail.toString(), ...head]);
+  if (!doFull && allEvents.size === 1) {
+    // console.log('head contains tail', tail.toString())
+    return []
+    // const event = await events.get(tail)
+    // return [event]
+  }
+
+  // console.log('finding events')
+  // console.log(callTag + '.head', head.length, [...head.map((h) => h.toString())], tail.toString())
+
+  // console.time(callTag + '.findEvents')
   const all = await Promise.all(head.map((h) => findEvents(events, h, tail)));
+  // console.timeEnd(callTag + '.findEvents')
   for (const arr of all) {
     for (const { event, depth } of arr) {
       // console.log('event value', event.value.data.value)
@@ -5823,7 +5849,7 @@ async function findSortedEvents (events, head, tail) {
   const sorted = Array.from(buckets)
     .sort((a, b) => b[0] - a[0])
     .flatMap(([, es]) => es.sort((a, b) => (String(a.cid) < String(b.cid) ? -1 : 1)));
-  // console.log('sorted', sorted.map(s => s.value.data.value))
+  // console.log('sorted', sorted.map(s => s.cid))
 
   return sorted
 }
@@ -5835,11 +5861,14 @@ async function findSortedEvents (events, head, tail) {
  * @returns {Promise<Array<{ event: EventBlockView<EventData>, depth: number }>>}
  */
 async function findEvents (events, start, end, depth = 0) {
-  // console.log('findEvents', start)
+  // console.log('findEvents', start.toString(), end.toString(), depth)
   const event = await events.get(start);
+  const send = String(end);
   const acc = [{ event, depth }];
   const { parents } = event.value;
-  if (parents.length === 1 && String(parents[0]) === String(end)) return acc
+  // if (parents.length === 1 && String(parents[0]) === send) return acc
+  if (parents.findIndex((p) => String(p) === send) !== -1) return acc
+  // if (parents.length === 1) return acc
   const rest = await Promise.all(parents.map((p) => findEvents(events, p, end, depth + 1)));
   return acc.concat(...rest)
 }
@@ -7046,6 +7075,8 @@ var varint$1 = {
   , encodingLength: length$1
 };
 
+var varint$2 = /*@__PURE__*/getDefaultExportFromCjs(varint$1);
+
 const CIDV0_BYTES = {
   SHA2_256: 0x12,
   LENGTH: 0x20,
@@ -7070,8 +7101,8 @@ function decodeVarint (bytes, seeker) {
   if (!bytes.length) {
     throw new Error('Unexpected end of data')
   }
-  const i = varint$1.decode(bytes);
-  seeker.seek(/** @type {number} */(varint$1.decode.bytes));
+  const i = varint$2.decode(bytes);
+  seeker.seek(/** @type {number} */(varint$2.decode.bytes));
   return i
   /* c8 ignore next 2 */
   // Node.js 12 c8 bug
@@ -7122,10 +7153,10 @@ function getMultihashLength (bytes) {
   // where both code and length are varints, so we have to decode
   // them first before we can know total length
 
-  varint$1.decode(bytes); // code
-  const codeLength = /** @type {number} */(varint$1.decode.bytes);
-  const length = varint$1.decode(bytes.subarray(varint$1.decode.bytes));
-  const lengthLength = /** @type {number} */(varint$1.decode.bytes);
+  varint$2.decode(bytes); // code
+  const codeLength = /** @type {number} */(varint$2.decode.bytes);
+  const length = varint$2.decode(bytes.subarray(varint$2.decode.bytes));
+  const lengthLength = /** @type {number} */(varint$2.decode.bytes);
   const mhLength = codeLength + lengthLength + length;
 
   return mhLength
@@ -7833,7 +7864,7 @@ const addRoot = (writer, root, options = {}) => {
  */
 const blockLength = ({ cid, bytes }) => {
   const size = cid.bytes.byteLength + bytes.byteLength;
-  return varint$1.encodingLength(size) + size
+  return varint$2.encodingLength(size) + size
 };
 
 /**
@@ -7842,7 +7873,7 @@ const blockLength = ({ cid, bytes }) => {
  */
 const addBlock = (writer, { cid, bytes }) => {
   const byteLength = cid.bytes.byteLength + bytes.byteLength;
-  const size = varint$1.encode(byteLength);
+  const size = varint$2.encode(byteLength);
   if (writer.byteOffset + size.length + byteLength > writer.bytes.byteLength) {
     throw new RangeError('Buffer has no capacity for this block')
   } else {
@@ -7862,7 +7893,7 @@ const close = (writer, options = {}) => {
   const { roots, bytes, byteOffset, headerSize } = writer;
 
   const headerBytes = encode$5({ version: 1, roots });
-  const varintBytes = varint$1.encode(headerBytes.length);
+  const varintBytes = varint$2.encode(headerBytes.length);
 
   const size = varintBytes.length + headerBytes.byteLength;
   const offset = headerSize - size;
@@ -7939,7 +7970,7 @@ const calculateHeaderLength = (rootLengths) => {
     tokens.push(new Token(Type.bytes, { length: rootLength + 1 }));
   }
   const length = tokensToLength(tokens); // no options needed here because we have simple tokens
-  return varint$1.encodingLength(length) + length
+  return varint$2.encodingLength(length) + length
 };
 
 /**
@@ -8282,23 +8313,11 @@ replaceTraps((oldTraps) => ({
     has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
 }));
 
-var cargoQueueExports = {};
-var cargoQueue$1 = {
-  get exports(){ return cargoQueueExports; },
-  set exports(v){ cargoQueueExports = v; },
-};
+var cargoQueue$1 = {exports: {}};
 
-var queueExports = {};
-var queue$1 = {
-  get exports(){ return queueExports; },
-  set exports(v){ queueExports = v; },
-};
+var queue$1 = {exports: {}};
 
-var onlyOnceExports = {};
-var onlyOnce = {
-  get exports(){ return onlyOnceExports; },
-  set exports(v){ onlyOnceExports = v; },
-};
+var onlyOnce = {exports: {}};
 
 (function (module, exports) {
 
@@ -8314,8 +8333,10 @@ var onlyOnce = {
 	        callFn.apply(this, args);
 	    };
 	}
-	module.exports = exports["default"];
-} (onlyOnce, onlyOnceExports));
+	module.exports = exports["default"]; 
+} (onlyOnce, onlyOnce.exports));
+
+var onlyOnceExports = onlyOnce.exports;
 
 var setImmediate$1 = {};
 
@@ -8352,11 +8373,7 @@ if (hasQueueMicrotask) {
 
 setImmediate$1.default = wrap(_defer);
 
-var DoublyLinkedListExports = {};
-var DoublyLinkedList = {
-  get exports(){ return DoublyLinkedListExports; },
-  set exports(v){ DoublyLinkedListExports = v; },
-};
+var DoublyLinkedList = {exports: {}};
 
 (function (module, exports) {
 
@@ -8449,22 +8466,16 @@ var DoublyLinkedList = {
 	    dll.length = 1;
 	    dll.head = dll.tail = node;
 	}
-	module.exports = exports["default"];
-} (DoublyLinkedList, DoublyLinkedListExports));
+	module.exports = exports["default"]; 
+} (DoublyLinkedList, DoublyLinkedList.exports));
+
+var DoublyLinkedListExports = DoublyLinkedList.exports;
 
 var wrapAsync = {};
 
-var asyncifyExports = {};
-var asyncify = {
-  get exports(){ return asyncifyExports; },
-  set exports(v){ asyncifyExports = v; },
-};
+var asyncify = {exports: {}};
 
-var initialParamsExports = {};
-var initialParams = {
-  get exports(){ return initialParamsExports; },
-  set exports(v){ initialParamsExports = v; },
-};
+var initialParams = {exports: {}};
 
 (function (module, exports) {
 
@@ -8479,13 +8490,15 @@ var initialParams = {
 	    };
 	};
 
-	module.exports = exports["default"];
-} (initialParams, initialParamsExports));
+	module.exports = exports["default"]; 
+} (initialParams, initialParams.exports));
+
+var initialParamsExports = initialParams.exports;
 
 var hasRequiredAsyncify;
 
 function requireAsyncify () {
-	if (hasRequiredAsyncify) return asyncifyExports;
+	if (hasRequiredAsyncify) return asyncify.exports;
 	hasRequiredAsyncify = 1;
 	(function (module, exports) {
 
@@ -8604,9 +8617,9 @@ function requireAsyncify () {
 		        }, err);
 		    }
 		}
-		module.exports = exports['default'];
-} (asyncify, asyncifyExports));
-	return asyncifyExports;
+		module.exports = exports['default']; 
+	} (asyncify, asyncify.exports));
+	return asyncify.exports;
 }
 
 var hasRequiredWrapAsync;
@@ -8943,8 +8956,10 @@ function requireWrapAsync () {
 	    });
 	    return q;
 	}
-	module.exports = exports['default'];
-} (queue$1, queueExports));
+	module.exports = exports['default']; 
+} (queue$1, queue$1.exports));
+
+var queueExports = queue$1.exports;
 
 (function (module, exports) {
 
@@ -9016,9 +9031,10 @@ function requireWrapAsync () {
 	function cargo(worker, concurrency, payload) {
 	  return (0, _queue2.default)(worker, concurrency, payload);
 	}
-	module.exports = exports['default'];
-} (cargoQueue$1, cargoQueueExports));
+	module.exports = exports['default']; 
+} (cargoQueue$1, cargoQueue$1.exports));
 
+var cargoQueueExports = cargoQueue$1.exports;
 var cargoQueue = /*@__PURE__*/getDefaultExportFromCjs(cargoQueueExports);
 
 var cryptoBrowserify = {};
@@ -9055,11 +9071,7 @@ var _polyfillNode_inherits = /*#__PURE__*/Object.freeze({
 
 var require$$3$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_inherits);
 
-var readableBrowserExports = {};
-var readableBrowser = {
-  get exports(){ return readableBrowserExports; },
-  set exports(v){ readableBrowserExports = v; },
-};
+var readableBrowser = {exports: {}};
 
 var domain;
 
@@ -13456,8 +13468,10 @@ var pipeline_1 = pipeline;
 	exports.Transform = _stream_transform;
 	exports.PassThrough = _stream_passthrough;
 	exports.finished = endOfStream;
-	exports.pipeline = pipeline_1;
-} (readableBrowser, readableBrowserExports));
+	exports.pipeline = pipeline_1; 
+} (readableBrowser, readableBrowser.exports));
+
+var readableBrowserExports = readableBrowser.exports;
 
 var Buffer$E = safeBufferExports.Buffer;
 var Transform$6 = readableBrowserExports.Transform;
@@ -13863,11 +13877,7 @@ function fn5 (a, b, c, d, e, m, k, s) {
 
 var ripemd160 = RIPEMD160$4;
 
-var sha_jsExports = {};
-var sha_js = {
-  get exports(){ return sha_jsExports; },
-  set exports(v){ sha_jsExports = v; },
-};
+var sha_js = {exports: {}};
 
 var Buffer$B = safeBufferExports.Buffer;
 
@@ -14671,6 +14681,8 @@ exports$1.sha256 = sha256$1;
 exports$1.sha384 = sha384$1;
 exports$1.sha512 = sha512$1;
 
+var sha_jsExports = sha_js.exports;
+
 function BufferList() {
   this.head = null;
   this.tail = null;
@@ -16621,12 +16633,6 @@ var browser$9 = function createHmac (alg, key) {
   return new Hmac$2(alg, key)
 };
 
-var algosExports = {};
-var algos = {
-  get exports(){ return algosExports; },
-  set exports(v){ algosExports = v; },
-};
-
 var sha224WithRSAEncryption = {
 	sign: "rsa",
 	hash: "sha224",
@@ -16791,9 +16797,7 @@ var require$$6 = {
 }
 };
 
-(function (module) {
-	module.exports = require$$6;
-} (algos));
+var algos = require$$6;
 
 var browser$8 = {};
 
@@ -19033,7 +19037,7 @@ var modes = {};
 	exports['des-ede'] = {
 	  key: 16,
 	  iv: 0
-	};
+	}; 
 } (modes));
 
 var DES = browserifyDes;
@@ -19106,11 +19110,9 @@ browser$7.listCiphers = browser$7.getCiphers = getCiphers;
 
 var browser$5 = {};
 
-var bnExports$1 = {};
-var bn$1 = {
-  get exports(){ return bnExports$1; },
-  set exports(v){ bnExports$1 = v; },
-};
+var bn$1 = {exports: {}};
+
+bn$1.exports;
 
 (function (module) {
 	(function (module, exports) {
@@ -22555,19 +22557,17 @@ var bn$1 = {
 	    var res = this.imod(a._invmp(this.m).mul(this.r2));
 	    return res._forceRed(this);
 	  };
-	})(module, commonjsGlobal);
+	})(module, commonjsGlobal); 
 } (bn$1));
 
-var brorandExports = {};
-var brorand = {
-  get exports(){ return brorandExports; },
-  set exports(v){ brorandExports = v; },
-};
+var bnExports$1 = bn$1.exports;
+
+var brorand = {exports: {}};
 
 var hasRequiredBrorand;
 
 function requireBrorand () {
-	if (hasRequiredBrorand) return brorandExports;
+	if (hasRequiredBrorand) return brorand.exports;
 	hasRequiredBrorand = 1;
 	var r;
 
@@ -22581,7 +22581,7 @@ function requireBrorand () {
 	function Rand(rand) {
 	  this.rand = rand;
 	}
-	brorandExports.Rand = Rand;
+	brorand.exports.Rand = Rand;
 
 	Rand.prototype.generate = function generate(len) {
 	  return this._rand(len);
@@ -22634,7 +22634,7 @@ function requireBrorand () {
 	  } catch (e) {
 	  }
 	}
-	return brorandExports;
+	return brorand.exports;
 }
 
 var mr;
@@ -23141,17 +23141,11 @@ function requireBrowser$2 () {
 	return browser$5;
 }
 
-var signExports = {};
-var sign = {
-  get exports(){ return signExports; },
-  set exports(v){ signExports = v; },
-};
+var sign = {exports: {}};
 
-var bnExports = {};
-var bn = {
-  get exports(){ return bnExports; },
-  set exports(v){ bnExports = v; },
-};
+var bn = {exports: {}};
+
+bn.exports;
 
 (function (module) {
 	(function (module, exports) {
@@ -26501,9 +26495,11 @@ var bn = {
 	    var res = this.imod(a._invmp(this.m).mul(this.r2));
 	    return res._forceRed(this);
 	  };
-	})(module, commonjsGlobal);
+	})(module, commonjsGlobal); 
 } (bn));
 
+var bnExports = bn.exports;
+
 var BN$a = bnExports;
 var randomBytes$1 = browserExports$1;
 
@@ -26674,7 +26670,7 @@ var utils$k = {};
 	    return toHex(arr);
 	  else
 	    return arr;
-	};
+	}; 
 } (utils$k));
 
 (function (exports) {
@@ -26794,7 +26790,7 @@ var utils$k = {};
 	function intFromLE(bytes) {
 	  return new BN(bytes, 'hex', 'le');
 	}
-	utils.intFromLE = intFromLE;
+	utils.intFromLE = intFromLE; 
 } (utils$l));
 
 var curve = {};
@@ -28733,7 +28729,7 @@ Point.prototype.mixedAdd = Point.prototype.add;
 	curve.base = base$2;
 	curve.short = short;
 	curve.mont = mont;
-	curve.edwards = edwards;
+	curve.edwards = edwards; 
 } (curve));
 
 var curves$1 = {};
@@ -29946,7 +29942,7 @@ Hmac.prototype.digest = function digest(enc) {
 	hash.sha224 = hash.sha.sha224;
 	hash.sha384 = hash.sha.sha384;
 	hash.sha512 = hash.sha.sha512;
-	hash.ripemd160 = hash.ripemd.ripemd160;
+	hash.ripemd160 = hash.ripemd.ripemd160; 
 } (hash$2));
 
 var secp256k1;
@@ -30943,7 +30939,7 @@ function requireSecp256k1 () {
 	    '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
 	    pre,
 	  ],
-	});
+	}); 
 } (curves$1));
 
 var hash$1 = hash$2;
@@ -31886,8 +31882,8 @@ function requireElliptic () {
 
 		// Protocols
 		elliptic.ec = requireEc();
-		elliptic.eddsa = eddsa;
-} (elliptic));
+		elliptic.eddsa = eddsa; 
+	} (elliptic));
 	return elliptic;
 }
 
@@ -32947,7 +32943,7 @@ var der$2 = {};
 	  0x1d: 'charstr',
 	  0x1e: 'bmpstr'
 	};
-	exports.tagByName = reverse(exports.tag);
+	exports.tagByName = reverse(exports.tag); 
 } (der$2));
 
 const inherits$3 = require$$3$1;
@@ -33271,7 +33267,7 @@ PEMEncoder.prototype.encode = function encode(data, options) {
 	const encoders = exports;
 
 	encoders.der = der_1$1;
-	encoders.pem = pem$1;
+	encoders.pem = pem$1; 
 } (encoders));
 
 var decoders = {};
@@ -33665,7 +33661,7 @@ PEMDecoder.prototype.decode = function decode(data, options) {
 	const decoders = exports;
 
 	decoders.der = der_1;
-	decoders.pem = pem;
+	decoders.pem = pem; 
 } (decoders));
 
 (function (exports) {
@@ -33724,7 +33720,7 @@ PEMDecoder.prototype.decode = function decode(data, options) {
 
 	Entity.prototype.encode = function encode(data, enc, /* internal */ reporter) {
 	  return this._getEncoder(enc).encode(data, reporter);
-	};
+	}; 
 } (api));
 
 var base$1 = {};
@@ -33736,7 +33732,7 @@ var base$1 = {};
 	base.Reporter = reporter.Reporter;
 	base.DecoderBuffer = buffer.DecoderBuffer;
 	base.EncoderBuffer = buffer.EncoderBuffer;
-	base.Node = node;
+	base.Node = node; 
 } (base$1));
 
 var constants = {};
@@ -33761,7 +33757,7 @@ var constants = {};
 	  return res;
 	};
 
-	constants.der = der$2;
+	constants.der = der$2; 
 } (constants));
 
 (function (exports) {
@@ -33774,7 +33770,7 @@ var constants = {};
 	asn1.base = base$1;
 	asn1.constants = constants;
 	asn1.decoders = decoders;
-	asn1.encoders = encoders;
+	asn1.encoders = encoders; 
 } (asn1$2));
 
 var asn = asn1$2;
@@ -34148,7 +34144,7 @@ var require$$4 = {
 var hasRequiredSign;
 
 function requireSign () {
-	if (hasRequiredSign) return signExports;
+	if (hasRequiredSign) return sign.exports;
 	hasRequiredSign = 1;
 	// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
 	var Buffer = safeBufferExports.Buffer;
@@ -34291,9 +34287,9 @@ function requireSign () {
 	}
 
 	sign.exports = sign$1;
-	signExports.getKey = getKey;
-	signExports.makeKey = makeKey;
-	return signExports;
+	sign.exports.getKey = getKey;
+	sign.exports.makeKey = makeKey;
+	return sign.exports;
 }
 
 var verify_1;
@@ -34872,7 +34868,7 @@ function compare$3 (a, b) {
 
 	exports.publicDecrypt = function publicDecrypt (key, buf) {
 	  return exports.privateDecrypt(key, buf, true)
-	};
+	}; 
 } (browser$2));
 
 var browser$1 = {};
@@ -34994,8 +34990,8 @@ function requireCryptoBrowserify () {
 	cryptoBrowserify.createHash = cryptoBrowserify.Hash = browser$a;
 	cryptoBrowserify.createHmac = cryptoBrowserify.Hmac = browser$9;
 
-	var algos = algosExports;
-	var algoKeys = Object.keys(algos);
+	var algos$1 = algos;
+	var algoKeys = Object.keys(algos$1);
 	var hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys);
 	cryptoBrowserify.getHashes = function () {
 	  return hashes
@@ -36928,7 +36924,7 @@ function rawSha1 (b) {
   return new Uint8Array(H.buffer, H.byteOffset, H.byteLength)
 }
 
-const chunker = bf(3);
+const chunker = bf(30);
 
 const NO_ENCRYPT = typeof process !== 'undefined' && !!process.env?.NO_ENCRYPT;
 // ? process.env.NO_ENCRYPT : import.meta && import.meta.env.VITE_NO_ENCRYPT
@@ -37377,7 +37373,10 @@ class TransactionBlockstore {
     await this.doCommit(innerBlockstore);
     if (doSync) {
       // const all =
-      await Promise.all([...this.syncs].map(async sync => sync.sendUpdate(innerBlockstore)));
+      await Promise.all([...this.syncs].map(async sync => sync.sendUpdate(innerBlockstore).catch(e => {
+        console.error('sync error', e);
+        this.syncs.delete(sync);
+      })));
     }
   }
 
@@ -37484,23 +37483,24 @@ class InnerBlockstore {
   }
 }
 
-const blockOpts = { cache: nocache, chunker: bf(3), codec: codec$1, hasher: sha256$2, compare: simpleCompare };
+const blockOpts = { cache: nocache, chunker: bf(30), codec: codec$1, hasher: sha256$2, compare: simpleCompare };
 
 /**
  * @typedef {import('./blockstore.js').TransactionBlockstore} TransactionBlockstore
  */
 
-const withLog = async (label, fn) => {
-  const resp = await fn();
-  // console.log('withLog', label, !!resp)
-  return resp
-};
+// const withLog = async (label, fn) => {
+//   const resp = await fn()
+//   // console.log('withLog', label, !!resp)
+//   return resp
+// }
 
 // should also return a CIDCounter
-const makeGetBlock = (blocks) => {
+const makeGetBlock = blocks => {
   // const cids = new CIDCounter() // this could be used for proofs of mutations
-  const getBlockFn = async (address) => {
-    const { cid, bytes } = await withLog(address, () => blocks.get(address));
+  const getBlockFn = async address => {
+    // 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 })
   };
@@ -37515,25 +37515,17 @@ const makeGetBlock = (blocks) => {
  * @param {*} param0
  * @returns
  */
-async function createAndSaveNewEvent ({
-  inBlocks,
-  bigPut,
-  root,
-  event: inEvent,
-  head,
-  additions,
-  removals = []
-}) {
+async function createAndSaveNewEvent ({ inBlocks, bigPut, root, event: inEvent, head, additions, removals = [] }) {
   let cids;
   const { key, value, del } = inEvent;
   const data = {
-    root: (root
+    root: root
       ? {
           cid: root.cid,
           bytes: root.bytes, // can we remove this?
           value: root.value // can we remove this?
         }
-      : null),
+      : null,
     key
   };
   // import('./clock').EventLink<import('./clock').EventData>
@@ -37561,7 +37553,7 @@ async function createAndSaveNewEvent ({
   }
 }
 
-const makeGetAndPutBlock = (inBlocks) => {
+const makeGetAndPutBlock = inBlocks => {
   // const mblocks = new MemoryBlockstore()
   // const blocks = new MultiBlockFetcher(mblocks, inBlocks)
   const { getBlock, cids } = makeGetBlock(inBlocks);
@@ -37620,20 +37612,24 @@ const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
   }
 };
 
-const doProllyBulk = async (inBlocks, head, event) => {
+const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
   const { getBlock, blocks } = makeGetAndPutBlock(inBlocks);
   let bulkSorted = [];
   let prollyRootNode = null;
   const events = new EventFetcher(blocks);
   if (head.length) {
-  // Otherwise, we find the common ancestor and update the root and other blocks
+    if (!doFull && head.length === 1) {
+      prollyRootNode = await prollyRootFromAncestor(events, head[0], getBlock);
+    } else {
+    // Otherwise, we find the common ancestor and update the root and other blocks
     // todo this is returning more events than necessary, lets define the desired semantics from the top down
     // good semantics mean we can cache the results of this call
-    const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head);
-    bulkSorted = sorted;
-    // console.log('sorted', JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
-    prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock);
+      const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head, doFull);
+      bulkSorted = sorted;
+      // console.log('sorted', JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
+      prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock);
     // console.log('event', event)
+    }
   }
 
   const bulkOperations = bulkFromEvents(bulkSorted, event);
@@ -37643,7 +37639,7 @@ const doProllyBulk = async (inBlocks, head, event) => {
     let root;
     const newBlocks = [];
     // if all operations are deletes, we can just return an empty root
-    if (bulkOperations.every((op) => op.del)) {
+    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 })) {
@@ -37663,7 +37659,7 @@ const doProllyBulk = async (inBlocks, head, event) => {
  *
  * @param {import('./blockstore.js').Blockstore} inBlocks Bucket block storage.
  * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
-* @param {{key: string, value: import('./clock').EventLink<import('./clock').EventData>}} event The key of the value to put.
+ * @param {{key: string, value: import('./clock').EventLink<import('./clock').EventData>}} event The key of the value to put.
  * @param {object} [options]
  * @returns {Promise<any>}
  */
@@ -37715,18 +37711,24 @@ async function put (inBlocks, head, event, options) {
  * @param {TransactionBlockstore} inBlocks Bucket block storage.
  * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
  */
-async function root (inBlocks, head) {
+async function root (inBlocks, head, doFull = false) {
   if (!head.length) {
     throw new Error('no head')
   }
-  const { root: newProllyRootNode, blocks: newBlocks, clockCIDs } = await doProllyBulk(inBlocks, head);
+  // console.log('root', head.map(h => h.toString()))
+  const { root: newProllyRootNode, blocks: newBlocks, clockCIDs } = await doProllyBulk(inBlocks, head, null, doFull);
   // todo maybe these should go to a temp blockstore?
-  await doTransaction('root', inBlocks, async (transactionBlocks) => {
-    const { bigPut } = makeGetAndPutBlock(transactionBlocks);
-    for (const nb of newBlocks) {
-      bigPut(nb);
-    }
-  }, false);
+  await doTransaction(
+    'root',
+    inBlocks,
+    async transactionBlocks => {
+      const { bigPut } = makeGetAndPutBlock(transactionBlocks);
+      for (const nb of newBlocks) {
+        bigPut(nb);
+      }
+    },
+    false
+  );
   return { clockCIDs, node: newProllyRootNode }
 }
 
@@ -37753,22 +37755,37 @@ async function eventsSince (blocks, head, since) {
  * @param {TransactionBlockstore} blocks Bucket block storage.
  * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
  *
- * @returns {Promise<{cids: CIDCounter, clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
+ * @returns {Promise<{root: any, cids: CIDCounter, clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
  *
  */
-async function getAll (blocks, head) {
+async function getAll (blocks, head, rootCache = null, doFull = false) {
   // todo use the root node left around from put, etc
   // move load to a central place
   if (!head.length) {
-    return { clockCIDs: new CIDCounter(), cids: new CIDCounter(), result: [] }
+    return { root: null, clockCIDs: new CIDCounter(), cids: new CIDCounter(), result: [] }
   }
-  const { node: prollyRootNode, clockCIDs } = await root(blocks, head);
+  const { node: prollyRootNode, clockCIDs } = await rootOrCache(blocks, head, rootCache, doFull);
 
   if (!prollyRootNode) {
-    return { clockCIDs, cids: new CIDCounter(), result: [] }
+    return { root: null, clockCIDs, cids: new CIDCounter(), result: [] }
   }
   const { result, cids } = await prollyRootNode.getAllEntries(); // todo params
-  return { clockCIDs, cids, result: result.map(({ key, value }) => ({ key, value })) }
+  return { root: prollyRootNode, clockCIDs, cids, result: result.map(({ key, value }) => ({ key, value })) }
+}
+
+async function rootOrCache (blocks, head, rootCache, doFull = false) {
+  let node;
+  let clockCIDs;
+  if (!doFull && rootCache && rootCache.root) {
+    // console.log('get root from cache', rootCache)
+    node = rootCache.root;
+    clockCIDs = rootCache.clockCIDs;
+  } else {
+({ node, clockCIDs } = await root(blocks, head, doFull));
+    // console.timeEnd(callTag + '.root')
+    // console.log('found root')
+  }
+  return { node, clockCIDs }
 }
 
 /**
@@ -37776,17 +37793,19 @@ async function getAll (blocks, head) {
  * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
  * @param {string} key The key of the value to retrieve.
  */
-async function get (blocks, head, key) {
+async function get (blocks, head, key, rootCache = null) {
   // instead pass root from db? and always update on change
   if (!head.length) {
     return { cids: new CIDCounter(), result: null }
   }
-  const { node: prollyRootNode, cids: clockCIDs } = await root(blocks, head);
+
+  const { node: prollyRootNode, clockCIDs } = await rootOrCache(blocks, head, rootCache);
+
   if (!prollyRootNode) {
     return { clockCIDs, cids: new CIDCounter(), result: null }
   }
   const { result, cids } = await prollyRootNode.get(key);
-  return { result, cids, clockCIDs }
+  return { result, cids, clockCIDs, root: prollyRootNode }
 }
 
 async function * vis (blocks, head) {
@@ -37803,8 +37822,19 @@ async function * vis (blocks, head) {
 }
 
 async function visMerkleTree (blocks, head) {
-  if (!head.length) {
-    return { cids: new CIDCounter(), result: null }
+  // if (!head) return
+  if (head && !Array.isArray(head)) {
+    const getBl = makeGetBlock(blocks);
+    const prollyRootNode = await load$2({
+      cid: head,
+      get: getBl.getBlock,
+      ...blockOpts
+    });
+    const lines = [];
+    for await (const line of prollyRootNode.vis()) {
+      lines.push(line);
+    }
+    return { vis: lines.join('\n'), cids: new CIDCounter() }
   }
   const { node: prollyRootNode, cids } = await root(blocks, head);
   const lines = [];
@@ -37823,7 +37853,7 @@ async function visMerkleClock (blocks, head) {
   return { vis: lines.join('\n') }
 }
 
-var charwise = {};
+var charwise$1 = {};
 
 var number = {};
 
@@ -38051,8 +38081,10 @@ object.factory = function (codec) {
 
 	//for leveldb, request strings
 	exports.buffer = false;
-	exports.type = 'charwise';
-} (charwise));
+	exports.type = 'charwise'; 
+} (charwise$1));
+
+var charwise = /*@__PURE__*/getDefaultExportFromCjs(charwise$1);
 
 /* global localStorage */
 let storageSupported = false;
@@ -38087,15 +38119,16 @@ const parseCID = cid => (typeof cid === 'string' ? CID$1.parse(cid) : cid);
  */
 class Database {
   listeners = new Set()
+  indexes = new Map()
+  rootCache = null
+  eventsCache = new Map()
 
-  // todo refactor this for the next version
   constructor (blocks, clock, config = {}) {
     this.name = config.name;
     this.instanceId = `fp.${this.name}.${Math.random().toString(36).substring(2, 7)}`;
     this.blocks = blocks;
     this.clock = clock;
     this.config = config;
-    this.indexes = new Map();
   }
 
   /**
@@ -38162,11 +38195,22 @@ class Database {
    * @instance
    */
   async changesSince (event) {
+    // console.log('events for', this.instanceId, event.constructor.name)
     // console.log('changesSince', this.instanceId, event, this.clock)
     let rows, dataCIDs, clockCIDs;
     // if (!event) event = []
     if (event) {
-      const resp = await eventsSince(this.blocks, this.clock, event);
+      event = event.map((cid) => cid.toString());
+      const eventKey = JSON.stringify([...event, ...this.clockToJSON()]);
+
+      let resp;
+      if (this.eventsCache.has(eventKey)) {
+        console.log('events from cache');
+        resp = this.eventsCache.get(eventKey);
+      } else {
+        resp = await eventsSince(this.blocks, this.clock, event);
+        this.eventsCache.set(eventKey, resp);
+      }
       const docsMap = new Map();
       for (const { key, type, value } of resp.result.map(decodeEvent)) {
         if (type === 'del') {
@@ -38179,7 +38223,9 @@ class Database {
       clockCIDs = resp.clockCIDs;
       // console.log('change rows', this.instanceId, rows)
     } else {
-      const allResp = await getAll(this.blocks, this.clock);
+      const allResp = await getAll(this.blocks, this.clock, this.rootCache);
+      this.rootCache = { root: allResp.root, clockCIDs: allResp.clockCIDs };
+
       rows = allResp.result.map(({ key, value }) => decodeEvent({ key, value }));
       dataCIDs = allResp.cids;
       // console.log('dbdoc rows', this.instanceId, rows)
@@ -38192,7 +38238,9 @@ class Database {
   }
 
   async allDocuments () {
-    const allResp = await getAll(this.blocks, this.clock);
+    const allResp = await getAll(this.blocks, this.clock, this.rootCache);
+    this.rootCache = { root: allResp.root, clockCIDs: allResp.clockCIDs };
+
     const rows = allResp.result
       .map(({ key, value }) => decodeEvent({ key, value }))
       .map(({ key, value }) => ({ key, value: { _id: key, ...value } }));
@@ -38204,7 +38252,8 @@ class Database {
   }
 
   async allCIDs () {
-    const allResp = await getAll(this.blocks, this.clock);
+    const allResp = await getAll(this.blocks, this.clock, this.rootCache, true);
+    this.rootCache = { root: allResp.root, clockCIDs: allResp.clockCIDs };
     // console.log('allcids', allResp.cids, allResp.clockCIDs)
     const cids = await cidsToProof(allResp.cids);
     const clockCids = await cidsToProof(allResp.clockCIDs);
@@ -38250,13 +38299,13 @@ class Database {
    */
   async get (key, opts = {}) {
     const clock = opts.clock || this.clock;
-    const resp = await get(this.blocks, clock, charwise.encode(key));
-
+    const resp = await get(this.blocks, clock, charwise.encode(key), this.rootCache);
+    this.rootCache = { root: resp.root, clockCIDs: resp.clockCIDs };
     // this tombstone is temporary until we can get the prolly tree to delete
     if (!resp || resp.result === null) {
       throw new Error('Not found')
     }
-    const doc = resp.result;
+    const doc = { ...resp.result };
     if (opts.mvcc === true) {
       doc._clock = this.clockToJSON();
     }
@@ -38350,7 +38399,9 @@ class Database {
   }
 
   applyClock (prevClock, newClock) {
-    // console.log('applyClock', prevClock, newClock, this.clock)
+    // console.log('prevClock', prevClock.length, prevClock.map((cid) => cid.toString()))
+    // console.log('newClock', newClock.length, newClock.map((cid) => cid.toString()))
+    // console.log('this.clock', this.clock.length, this.clockToJSON())
     const stPrev = prevClock.map(cid => cid.toString());
     const keptPrevClock = this.clock.filter(cid => stPrev.indexOf(cid.toString()) === -1);
     const merged = keptPrevClock.concat(newClock);
@@ -38358,8 +38409,10 @@ class Database {
     for (const cid of merged) {
       uniquebyCid.set(cid.toString(), cid);
     }
-    this.clock = Array.from(uniquebyCid.values());
-    // console.log('afterClock', this.clock)
+    this.clock = Array.from(uniquebyCid.values()).sort((a, b) => a.toString().localeCompare(b.toString()));
+    this.rootCache = null;
+    this.eventsCache.clear();
+    // console.log('afterClock', this.clock.length, this.clockToJSON())
   }
 
   //   /**
@@ -38695,8 +38748,8 @@ const refCompare = (aRef, bRef) => {
   return simpleCompare(aRef, bRef)
 };
 
-const dbIndexOpts = { cache: nocache, chunker: bf(3), codec: codec$1, hasher: sha256$2, compare };
-const idIndexOpts = { cache: nocache, chunker: bf(3), codec: codec$1, hasher: sha256$2, compare: simpleCompare };
+const dbIndexOpts = { cache: nocache, chunker: bf(30), codec: codec$1, hasher: sha256$2, compare };
+const idIndexOpts = { cache: nocache, chunker: bf(30), codec: codec$1, hasher: sha256$2, compare: simpleCompare };
 
 const makeDoc = ({ key, value }) => ({ _id: key, ...value });
 
@@ -38753,6 +38806,9 @@ const indexEntriesForChanges = (changes, mapFn) => {
  *
  */
 class DbIndex {
+  /**
+   * @param {Database} database
+   */
   constructor (database, name, mapFn, clock = null, opts = {}) {
     this.database = database;
     if (!database.indexBlocks) {
@@ -38824,6 +38880,14 @@ class DbIndex {
     return new DbIndex(database, name, code, clock)
   }
 
+  async visKeyTree () {
+    return await visMerkleTree(this.database.indexBlocks, this.indexById.cid)
+  }
+
+  async visIdTree () {
+    return await visMerkleTree(this.database.indexBlocks, this.indexByKey.cid)
+  }
+
   /**
    * JSDoc for Query type.
    * @typedef {Object} DbQuery
@@ -38993,11 +39057,7 @@ async function doIndexQuery (blocks, indexByKey, query = {}) {
   }
 }
 
-var browserExports = {};
-var browser = {
-  get exports(){ return browserExports; },
-  set exports(v){ browserExports = v; },
-};
+var browser = {exports: {}};
 
 /**
  * Helpers.
@@ -39713,8 +39773,10 @@ var common = setup;
 		} catch (error) {
 			return '[UnexpectedJSONParseError]: ' + error.message;
 		}
-	};
-} (browser, browserExports));
+	}; 
+} (browser, browser.exports));
+
+var browserExports = browser.exports;
 
 // originally pulled out of simple-peer
 
@@ -40865,6 +40927,8 @@ Peer.channelConfig = {};
 
 var simplePeer = Peer;
 
+var SimplePeer = /*@__PURE__*/getDefaultExportFromCjs(simplePeer);
+
 /**
  * @typedef {import('./database.js').Database} Database
  */
@@ -40875,9 +40939,9 @@ class Sync {
    * @memberof Sync
    * @static
    */
-  constructor (database, PeerClass = simplePeer) {
+  constructor (database, PeerClass = SimplePeer) {
     this.database = database;
-    this.database.blocks.syncs.add(this);
+    this.database.blocks.syncs.add(this); // should this happen during setup?
     this.PeerClass = PeerClass;
     this.pushBacklog = new Promise((resolve, reject) => {
       this.pushBacklogResolve = resolve;
@@ -40925,8 +40989,13 @@ class Sync {
 
   async gotData (data) {
     // console.log('got data', data.toString())
+    let reader = null;
     try {
-      const reader = await CarReader.fromBytes(data);
+      reader = await CarReader.fromBytes(data);
+    } catch (e) {
+      // console.log('not a car', data.toString())
+    }
+    if (reader) {
       const blz = new Set();
       for await (const block of reader.blocks()) {
         blz.add(block);
@@ -40949,17 +41018,22 @@ class Sync {
         get: async cid => await reader.get(cid),
         lastCid: [...blz][0].cid // doesn't matter
       }, false);
-      this.database.applyClock([], roots);
+      // first arg could be the roots parents?
+      // get the roots parents
+      const parents = await Promise.all(roots.map(async (cid) => {
+        const rbl = await reader.get(cid);
+        if (!rbl) {
+          console.log('missing root block', cid.toString(), reader);
+          throw new Error('missing root block')
+        }
+        const block = await decodeEventBlock(rbl.bytes);
+        return block.value.parents
+      }));
+      this.database.applyClock(parents.flat(), roots);
       this.database.notifyReset();
       // console.log('after', this.database.clockToJSON())
       this.pushBacklogResolve({ ok: true });
-    } catch (e) {
-      // console.error(e)
-      // if e.message matche 'CBOR' we can ignore it
-      if (!e.message.match(/CBOR|fromBytes/)) {
-        throw e
-      }
-
+    } else {
       // data is a json string, parse it
       const message = JSON.parse(data.toString());
       // console.log('got message', message)
@@ -40968,7 +41042,7 @@ class Sync {
       } else if (message.clock) {
         const reqCidDiff = message;
         // this might be a CID diff
-        // console.log('got diff', reqCidDiff)
+        console.log('got diff', reqCidDiff);
         const carBlock = await Sync.makeCar(this.database, null, reqCidDiff.cids);
         if (!carBlock) {
         // we are full synced
@@ -40985,7 +41059,7 @@ class Sync {
   }
 
   async sendUpdate (blockstore) {
-    console.log('send update from', this.database.instanceId);
+    // console.log('send update from', this.database.instanceId)
     // todo should send updates since last sync
     const newCar = await blocksToCarBlock(blockstore.lastCid, blockstore);
     this.peer.send(newCar.bytes);
@@ -41071,9 +41145,9 @@ class Fireproof {
       if (existing) {
         const existingConfig = JSON.parse(existing);
         const fp = new Database(new TransactionBlockstore(name, existingConfig.key), [], opts);
-        return this.fromJSON(existingConfig, fp)
+        return Fireproof.fromJSON(existingConfig, fp)
       } else {
-        const instanceKey = browserExports$1(32).toString('hex'); // pass null to disable encryption
+        const instanceKey = randomBytes$3(32).toString('hex'); // pass null to disable encryption
         return new Database(new TransactionBlockstore(name, instanceKey), [], opts)
       }
     } else {
@@ -41114,7 +41188,7 @@ class Fireproof {
         index.clock.db = null;
       });
     }
-    const snappedDb = this.fromJSON(definition, withBlocks)
+    const snappedDb = Fireproof.fromJSON(definition, withBlocks)
     ;[...database.indexes.values()].forEach(index => {
       snappedDb.indexes.get(index.mapFnString).mapFn = index.mapFn;
     });