@fireproof/core 0.5.13 → 0.5.14

package/dist/src/fireproof.mjs

@@ -5497,17 +5497,17 @@ class CIDCounter {
 
 /**
  * @typedef {{
-*   type: 'put'|'del'
-*   key: string
-*   value: import('./link').AnyLink
-*   root: import('./link').AnyLink
-* }} EventData
-* @typedef {{
-*   root: import('./link').AnyLink
-*   head: import('./clock').EventLink<EventData>[]
-*   event: import('./clock').EventBlockView<EventData>
-* }} Result
-*/
+ *   type: 'put'|'del'
+ *   key: string
+ *   value: import('./link').AnyLink
+ *   root: import('./link').AnyLink
+ * }} EventData
+ * @typedef {{
+ *   root: import('./link').AnyLink
+ *   head: import('./clock').EventLink<EventData>[]
+ *   event: import('./clock').EventBlockView<EventData>
+ * }} Result
+ */
 
 /**
  * Advance the clock by adding an event.
@@ -5521,7 +5521,7 @@ class CIDCounter {
 async function advance (blocks, head, event) {
   /** @type {EventFetcher<T>} */
   const events = new EventFetcher(blocks);
-  const headmap = new Map(head.map((cid) => [cid.toString(), cid]));
+  const headmap = new Map(head.map(cid => [cid.toString(), cid]));
 
   // Check if the headmap already includes the event, return head if it does
   if (headmap.has(event.toString())) return { head, cids: await events.all() }
@@ -5643,14 +5643,16 @@ async function decodeEventBlock (bytes) {
 async function contains (events, a, b) {
   if (a.toString() === b.toString()) return true
   const [{ value: aevent }, { value: bevent }] = await Promise.all([events.get(a), events.get(b)]);
-  const links = [...aevent.parents];
+  // const links = [...aevent.parents]
+  // console.log('aevent', aevent.parents)
+  const links = [...(aevent.parents || [])];
   while (links.length) {
     const link = links.shift();
     if (!link) break
     if (link.toString() === b.toString()) return true
     // if any of b's parents are this link, then b cannot exist in any of the
     // tree below, since that would create a cycle.
-    if (bevent.parents.some((p) => link.toString() === p.toString())) continue
+    if (bevent.parents.some(p => link.toString() === p.toString())) continue
     const { value: event } = await events.get(link);
     links.push(...event.parents);
   }
@@ -5666,15 +5668,19 @@ async function contains (events, a, b) {
  */
 async function * vis$1 (blocks, head, options = {}) {
   // @ts-ignore
-  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 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;';
-  const hevents = await Promise.all(head.map((link) => events.get(link)));
+  const hevents = await Promise.all(head.map(link => events.get(link)));
   const links = [];
   const nodes = new Set();
   for (const e of hevents) {
@@ -5707,17 +5713,18 @@ async function findEventsToSync (blocks, head) {
   // console.time(callTag + '.findCommonAncestorWithSortedEvents')
   const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head);
   // console.timeEnd(callTag + '.findCommonAncestorWithSortedEvents')
-  // console.log('sorted', sorted.length)
+  // console.log('sorted', !!ancestor, sorted.length)
   // console.time(callTag + '.contains')
-  const toSync = await asyncFilter(sorted, async (uks) => !(await contains(events, ancestor, uks.cid)));
+
+  const toSync = ancestor ? await asyncFilter(sorted, async uks => !(await contains(events, ancestor, uks.cid))) : sorted;
   // console.timeEnd(callTag + '.contains')
-  // console.log('toSync.contains', toSync.length)
+  console.log('toSync', !!ancestor, sorted.length - toSync.length);
 
   return { cids: events, events: toSync }
 }
 
 const asyncFilter = async (arr, predicate) =>
-  Promise.all(arr.map(predicate)).then((results) => arr.filter((_v, index) => results[index]));
+  Promise.all(arr.map(predicate)).then(results => arr.filter((_v, index) => results[index]));
 
 async function findCommonAncestorWithSortedEvents (events, children, doFull = false) {
   // console.trace('findCommonAncestorWithSortedEvents')
@@ -5728,12 +5735,16 @@ async function findCommonAncestorWithSortedEvents (events, children, doFull = fa
   // console.timeEnd(callTag + '.findCommonAncestor')
   // console.log('ancestor', ancestor.toString())
   if (!ancestor) {
-    throw new Error('failed to find common ancestor event')
+    console.log('no common ancestor', children);
+    // throw new Error('no common ancestor')
+    const sorted = await findSortedEvents(events, children, children, doFull);
+    return { ancestor: null, sorted }
   }
   // console.time(callTag + '.findSortedEvents')
-  const sorted = await findSortedEvents(events, children, ancestor, doFull);
+  const sorted = await findSortedEvents(events, children, [ancestor], doFull);
   // console.timeEnd(callTag + '.findSortedEvents')
   // console.log('sorted', sorted.length)
+  // console.log('ancestor', JSON.stringify(ancestor, null, 2))
   return { ancestor, sorted }
 }
 
@@ -5744,17 +5755,58 @@ async function findCommonAncestorWithSortedEvents (events, children, doFull = fa
  * @param {import('./clock').EventFetcher} events
  * @param  {import('./clock').EventLink<EventData>[]} children
  */
+// async function NEWfindCommonAncestor (events, children) {
+//   if (!children.length) return
+//   if (children.length === 1) return children[0]
+
+//   const candidates = children.map(c => [c])
+//   const visited = new Set()
+
+//   while (true) {
+//     let changed = false
+//     for (const c of candidates) {
+//       const candidate = await findAncestorCandidate(events, c[c.length - 1])
+
+//       if (!candidate) continue
+
+//       if (visited.has(candidate)) {
+//         return candidate // Common ancestor found
+//       }
+
+//       visited.add(candidate)
+//       changed = true
+//       c.push(candidate)
+//     }
+
+//     if (!changed) {
+//       // No common ancestor found, exhausted candidates
+//       return null
+//     }
+//   }
+// }
+
 async function findCommonAncestor (events, children) {
   if (!children.length) return
+  children = [...new Set(children)];
   if (children.length === 1) return children[0]
   const candidates = children.map((c) => [c]);
+  // console.log(
+  //   'og candidates',
+  //   candidates.map((c) => c.toString())
+  // )
   while (true) {
     let changed = false;
     for (const c of candidates) {
       const candidate = await findAncestorCandidate(events, c[c.length - 1]);
       if (!candidate) continue
+
+      // Check if the candidate is already in the list, and if so, skip it.
+      if (c.includes(candidate)) continue
+
+      // if set size is all cids, then no common ancestor
       changed = true;
-      c.push(candidate);
+      c.push(candidate); // make set?
+      // console.log('candidate', candidates.map((c) => c.toString()))
       const ancestor = findCommonString(candidates);
       if (ancestor) return ancestor
     }
@@ -5762,12 +5814,45 @@ async function findCommonAncestor (events, children) {
   }
 }
 
+// async function OGfindCommonAncestor (events, children) {
+//   if (!children.length) return
+//   if (children.length === 1) return children[0]
+//   const candidates = children.map(c => [c])
+//   console.log(
+//     'og candidates',
+//     candidates.map(c => c.toString())
+//   )
+//   while (true) {
+//     let changed = false
+//     for (const c of candidates) {
+//       const candidate = await findAncestorCandidate(events, c[c.length - 1])
+//       if (!candidate) continue
+//       // if set size is all cids, then no common ancestor
+//       changed = true
+//       c.push(candidate) // make set?
+//       console.log(
+//         'candidate',
+//         candidates.map(c => c.toString())
+//       )
+//       const ancestor = findCommonString(candidates)
+//       if (ancestor) return ancestor
+//     }
+//     if (!changed) return
+//   }
+// }
+
 /**
  * @param {import('./clock').EventFetcher} events
  * @param {import('./clock').EventLink<EventData>} root
  */
 async function findAncestorCandidate (events, root) {
-  const { value: event } = await events.get(root);// .catch(() => ({ value: { parents: [] } }))
+  const { value: event } = await events.get(root); // .catch(() => ({ value: { parents: [] } }))
+  // console.log(
+  //   'findAncestorCandidate',
+  //   root.toString(),
+  //   'parents',
+  //   event.parents.map(p => p.toString())
+  // )
   if (!event.parents.length) return root
   return event.parents.length === 1 ? event.parents[0] : findCommonAncestor(events, event.parents)
 }
@@ -5778,13 +5863,13 @@ async function findAncestorCandidate (events, root) {
  */
 function findCommonString (arrays) {
   // console.log('findCommonString', arrays.map((a) => a.map((i) => String(i))))
-  arrays = arrays.map((a) => [...a]);
+  arrays = arrays.map(a => [...a]);
   for (const arr of arrays) {
     for (const item of arr) {
       let matched = true;
       for (const other of arrays) {
         if (arr === other) continue
-        matched = other.some((i) => String(i) === String(item));
+        matched = other.some(i => String(i) === String(item));
         if (!matched) break
       }
       if (matched) return item
@@ -5796,19 +5881,19 @@ function findCommonString (arrays) {
  * Find and sort events between the head(s) and the tail.
  * @param {import('./clock').EventFetcher} events
  * @param {any[]} head
- * @param {import('./clock').EventLink<EventData>} tail
+ * @param {import('./clock').EventLink<EventData>[]} tails
  */
-async function findSortedEvents (events, head, tail, doFull) {
+async function findSortedEvents (events, head, tails, 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())])];
+  head = [...new Set([...head.map(h => h.toString())])];
   // console.log(callTag + '.head', head.length)
 
-  const allEvents = new Set([tail.toString(), ...head]);
+  const allEvents = new Set([tails.map((t) => t.toString()).toString(), ...head]);
   if (!doFull && allEvents.size === 1) {
     // console.log('head contains tail', tail.toString())
     return []
@@ -5820,7 +5905,8 @@ async function findSortedEvents (events, head, tail, doFull) {
   // 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)));
+  const all = await (await Promise.all(tails.map((t) => Promise.all(head.map(h => findEvents(events, h, t)))))).flat();
+  // console.log('all', all.length)
   // console.timeEnd(callTag + '.findEvents')
   for (const arr of all) {
     for (const { event, depth } of arr) {
@@ -5868,9 +5954,9 @@ async function findEvents (events, start, end, depth = 0) {
   const acc = [{ event, depth }];
   const { parents } = event.value;
   // if (parents.length === 1 && String(parents[0]) === send) return acc
-  if (parents.findIndex((p) => String(p) === send) !== -1) 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)));
+  const rest = await Promise.all(parents.map(p => findEvents(events, p, end, depth + 1)));
   return acc.concat(...rest)
 }
 
@@ -9571,15 +9657,7 @@ var _polyfillNode_events = /*#__PURE__*/Object.freeze({
 
 var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_events);
 
-var streamBrowser;
-var hasRequiredStreamBrowser;
-
-function requireStreamBrowser () {
-	if (hasRequiredStreamBrowser) return streamBrowser;
-	hasRequiredStreamBrowser = 1;
-	streamBrowser = require$$0$1.EventEmitter;
-	return streamBrowser;
-}
+var streamBrowser = require$$0$1.EventEmitter;
 
 // shim for using process in browser
 // based off https://github.com/defunctzombie/node-process/blob/master/browser.js
@@ -9722,7 +9800,7 @@ var argv = [];
 var version$2 = ''; // empty string to avoid regexp issues
 var versions = {};
 var release = {};
-var config = {};
+var config$1 = {};
 
 function noop$2() {}
 
@@ -9799,7 +9877,7 @@ var browser$1$1 = {
   hrtime: hrtime,
   platform: platform,
   release: release,
-  config: config,
+  config: config$1,
   uptime: uptime
 };
 
@@ -9880,11 +9958,11 @@ function format(f) {
 // Mark that a method should not be used.
 // Returns a modified function which warns once by default.
 // If --no-deprecation is set, then it is a no-op.
-function deprecate$1(fn, msg) {
+function deprecate$2(fn, msg) {
   // Allow for deprecating things in the process of starting up.
   if (isUndefined(global$1.process)) {
     return function() {
-      return deprecate$1(fn, msg).apply(this, arguments);
+      return deprecate$2(fn, msg).apply(this, arguments);
     };
   }
 
@@ -10493,7 +10571,7 @@ var _polyfillNode_util = {
   isBoolean: isBoolean,
   isArray: isArray,
   inspect: inspect,
-  deprecate: deprecate$1,
+  deprecate: deprecate$2,
   format: format,
   debuglog: debuglog,
   promisify: promisify,
@@ -10506,7 +10584,7 @@ var _polyfillNode_util$1 = /*#__PURE__*/Object.freeze({
 	callbackify: callbackify,
 	debuglog: debuglog,
 	default: _polyfillNode_util,
-	deprecate: deprecate$1,
+	deprecate: deprecate$2,
 	format: format,
 	inherits: inherits$w,
 	inspect: inspect,
@@ -10694,108 +10772,99 @@ function requireBuffer_list () {
 	return buffer_list;
 }
 
-var destroy_1;
-var hasRequiredDestroy;
-
-function requireDestroy () {
-	if (hasRequiredDestroy) return destroy_1;
-	hasRequiredDestroy = 1;
-
-	// undocumented cb() API, needed for core, not for public API
-	function destroy(err, cb) {
-	  const readableDestroyed = this._readableState && this._readableState.destroyed;
-	  const writableDestroyed = this._writableState && this._writableState.destroyed;
-	  if (readableDestroyed || writableDestroyed) {
-	    if (cb) {
-	      cb(err);
-	    } else if (err) {
-	      if (!this._writableState) {
-	        process.nextTick(emitErrorNT, this, err);
-	      } else if (!this._writableState.errorEmitted) {
-	        this._writableState.errorEmitted = true;
-	        process.nextTick(emitErrorNT, this, err);
-	      }
-	    }
-	    return this;
-	  }
+// undocumented cb() API, needed for core, not for public API
+function destroy(err, cb) {
+  const readableDestroyed = this._readableState && this._readableState.destroyed;
+  const writableDestroyed = this._writableState && this._writableState.destroyed;
+  if (readableDestroyed || writableDestroyed) {
+    if (cb) {
+      cb(err);
+    } else if (err) {
+      if (!this._writableState) {
+        process.nextTick(emitErrorNT, this, err);
+      } else if (!this._writableState.errorEmitted) {
+        this._writableState.errorEmitted = true;
+        process.nextTick(emitErrorNT, this, err);
+      }
+    }
+    return this;
+  }
 
-	  // we set destroyed to true before firing error callbacks in order
-	  // to make it re-entrance safe in case destroy() is called within callbacks
+  // we set destroyed to true before firing error callbacks in order
+  // to make it re-entrance safe in case destroy() is called within callbacks
 
-	  if (this._readableState) {
-	    this._readableState.destroyed = true;
-	  }
+  if (this._readableState) {
+    this._readableState.destroyed = true;
+  }
 
-	  // if this is a duplex stream mark the writable part as destroyed as well
-	  if (this._writableState) {
-	    this._writableState.destroyed = true;
-	  }
-	  this._destroy(err || null, err => {
-	    if (!cb && err) {
-	      if (!this._writableState) {
-	        process.nextTick(emitErrorAndCloseNT, this, err);
-	      } else if (!this._writableState.errorEmitted) {
-	        this._writableState.errorEmitted = true;
-	        process.nextTick(emitErrorAndCloseNT, this, err);
-	      } else {
-	        process.nextTick(emitCloseNT, this);
-	      }
-	    } else if (cb) {
-	      process.nextTick(emitCloseNT, this);
-	      cb(err);
-	    } else {
-	      process.nextTick(emitCloseNT, this);
-	    }
-	  });
-	  return this;
-	}
-	function emitErrorAndCloseNT(self, err) {
-	  emitErrorNT(self, err);
-	  emitCloseNT(self);
-	}
-	function emitCloseNT(self) {
-	  if (self._writableState && !self._writableState.emitClose) return;
-	  if (self._readableState && !self._readableState.emitClose) return;
-	  self.emit('close');
-	}
-	function undestroy() {
-	  if (this._readableState) {
-	    this._readableState.destroyed = false;
-	    this._readableState.reading = false;
-	    this._readableState.ended = false;
-	    this._readableState.endEmitted = false;
-	  }
-	  if (this._writableState) {
-	    this._writableState.destroyed = false;
-	    this._writableState.ended = false;
-	    this._writableState.ending = false;
-	    this._writableState.finalCalled = false;
-	    this._writableState.prefinished = false;
-	    this._writableState.finished = false;
-	    this._writableState.errorEmitted = false;
-	  }
-	}
-	function emitErrorNT(self, err) {
-	  self.emit('error', err);
-	}
-	function errorOrDestroy(stream, err) {
-	  // We have tests that rely on errors being emitted
-	  // in the same tick, so changing this is semver major.
-	  // For now when you opt-in to autoDestroy we allow
-	  // the error to be emitted nextTick. In a future
-	  // semver major update we should change the default to this.
-
-	  const rState = stream._readableState;
-	  const wState = stream._writableState;
-	  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
-	}
-	destroy_1 = {
-	  destroy,
-	  undestroy,
-	  errorOrDestroy
-	};
-	return destroy_1;
+  // if this is a duplex stream mark the writable part as destroyed as well
+  if (this._writableState) {
+    this._writableState.destroyed = true;
+  }
+  this._destroy(err || null, err => {
+    if (!cb && err) {
+      if (!this._writableState) {
+        process.nextTick(emitErrorAndCloseNT, this, err);
+      } else if (!this._writableState.errorEmitted) {
+        this._writableState.errorEmitted = true;
+        process.nextTick(emitErrorAndCloseNT, this, err);
+      } else {
+        process.nextTick(emitCloseNT, this);
+      }
+    } else if (cb) {
+      process.nextTick(emitCloseNT, this);
+      cb(err);
+    } else {
+      process.nextTick(emitCloseNT, this);
+    }
+  });
+  return this;
+}
+function emitErrorAndCloseNT(self, err) {
+  emitErrorNT(self, err);
+  emitCloseNT(self);
 }
+function emitCloseNT(self) {
+  if (self._writableState && !self._writableState.emitClose) return;
+  if (self._readableState && !self._readableState.emitClose) return;
+  self.emit('close');
+}
+function undestroy() {
+  if (this._readableState) {
+    this._readableState.destroyed = false;
+    this._readableState.reading = false;
+    this._readableState.ended = false;
+    this._readableState.endEmitted = false;
+  }
+  if (this._writableState) {
+    this._writableState.destroyed = false;
+    this._writableState.ended = false;
+    this._writableState.ending = false;
+    this._writableState.finalCalled = false;
+    this._writableState.prefinished = false;
+    this._writableState.finished = false;
+    this._writableState.errorEmitted = false;
+  }
+}
+function emitErrorNT(self, err) {
+  self.emit('error', err);
+}
+function errorOrDestroy(stream, err) {
+  // We have tests that rely on errors being emitted
+  // in the same tick, so changing this is semver major.
+  // For now when you opt-in to autoDestroy we allow
+  // the error to be emitted nextTick. In a future
+  // semver major update we should change the default to this.
+
+  const rState = stream._readableState;
+  const wState = stream._writableState;
+  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
+}
+var destroy_1 = {
+  destroy,
+  undestroy,
+  errorOrDestroy
+};
 
 var errorsBrowser = {};
 
@@ -10925,109 +10994,92 @@ createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
 createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
 errorsBrowser.codes = codes;
 
-var state;
-var hasRequiredState;
-
-function requireState () {
-	if (hasRequiredState) return state;
-	hasRequiredState = 1;
-
-	const ERR_INVALID_OPT_VALUE = errorsBrowser.codes.ERR_INVALID_OPT_VALUE;
-	function highWaterMarkFrom(options, isDuplex, duplexKey) {
-	  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
-	}
-	function getHighWaterMark(state, options, duplexKey, isDuplex) {
-	  const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
-	  if (hwm != null) {
-	    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
-	      const name = isDuplex ? duplexKey : 'highWaterMark';
-	      throw new ERR_INVALID_OPT_VALUE(name, hwm);
-	    }
-	    return Math.floor(hwm);
-	  }
-
-	  // Default value
-	  return state.objectMode ? 16 : 16 * 1024;
-	}
-	state = {
-	  getHighWaterMark
-	};
-	return state;
+const ERR_INVALID_OPT_VALUE = errorsBrowser.codes.ERR_INVALID_OPT_VALUE;
+function highWaterMarkFrom(options, isDuplex, duplexKey) {
+  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
 }
+function getHighWaterMark(state, options, duplexKey, isDuplex) {
+  const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+  if (hwm != null) {
+    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+      const name = isDuplex ? duplexKey : 'highWaterMark';
+      throw new ERR_INVALID_OPT_VALUE(name, hwm);
+    }
+    return Math.floor(hwm);
+  }
 
-var browser$b;
-var hasRequiredBrowser$3;
+  // Default value
+  return state.objectMode ? 16 : 16 * 1024;
+}
+var state = {
+  getHighWaterMark
+};
 
-function requireBrowser$3 () {
-	if (hasRequiredBrowser$3) return browser$b;
-	hasRequiredBrowser$3 = 1;
-	/**
-	 * Module exports.
-	 */
+/**
+ * Module exports.
+ */
 
-	browser$b = deprecate;
+var browser$b = deprecate$1;
 
-	/**
-	 * Mark that a method should not be used.
-	 * Returns a modified function which warns once by default.
-	 *
-	 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
-	 *
-	 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
-	 * will throw an Error when invoked.
-	 *
-	 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
-	 * will invoke `console.trace()` instead of `console.error()`.
-	 *
-	 * @param {Function} fn - the function to deprecate
-	 * @param {String} msg - the string to print to the console when `fn` is invoked
-	 * @returns {Function} a new "deprecated" version of `fn`
-	 * @api public
-	 */
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
 
-	function deprecate (fn, msg) {
-	  if (config('noDeprecation')) {
-	    return fn;
-	  }
+function deprecate$1 (fn, msg) {
+  if (config('noDeprecation')) {
+    return fn;
+  }
 
-	  var warned = false;
-	  function deprecated() {
-	    if (!warned) {
-	      if (config('throwDeprecation')) {
-	        throw new Error(msg);
-	      } else if (config('traceDeprecation')) {
-	        console.trace(msg);
-	      } else {
-	        console.warn(msg);
-	      }
-	      warned = true;
-	    }
-	    return fn.apply(this, arguments);
-	  }
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (config('throwDeprecation')) {
+        throw new Error(msg);
+      } else if (config('traceDeprecation')) {
+        console.trace(msg);
+      } else {
+        console.warn(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
 
-	  return deprecated;
-	}
+  return deprecated;
+}
 
-	/**
-	 * Checks `localStorage` for boolean values for the given `name`.
-	 *
-	 * @param {String} name
-	 * @returns {Boolean}
-	 * @api private
-	 */
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
 
-	function config (name) {
-	  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
-	  try {
-	    if (!commonjsGlobal.localStorage) return false;
-	  } catch (_) {
-	    return false;
-	  }
-	  var val = commonjsGlobal.localStorage[name];
-	  if (null == val) return false;
-	  return String(val).toLowerCase() === 'true';
-	}
-	return browser$b;
+function config (name) {
+  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+  try {
+    if (!commonjsGlobal.localStorage) return false;
+  } catch (_) {
+    return false;
+  }
+  var val = commonjsGlobal.localStorage[name];
+  if (null == val) return false;
+  return String(val).toLowerCase() === 'true';
 }
 
 var _stream_writable;
@@ -11058,12 +11110,12 @@ function require_stream_writable () {
 
 	/*<replacement>*/
 	const internalUtil = {
-	  deprecate: requireBrowser$3()
+	  deprecate: browser$b
 	};
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStreamBrowser();
+	var Stream = streamBrowser;
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -11074,8 +11126,8 @@ function require_stream_writable () {
 	function _isUint8Array(obj) {
 	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 	}
-	const destroyImpl = requireDestroy();
-	const _require = requireState(),
+	const destroyImpl = destroy_1;
+	const _require = state,
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -12269,7 +12321,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStreamBrowser();
+	var Stream = streamBrowser;
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -12292,8 +12344,8 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	const BufferList = requireBuffer_list();
-	const destroyImpl = requireDestroy();
-	const _require = requireState(),
+	const destroyImpl = destroy_1;
+	const _require = state,
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -15659,7 +15711,7 @@ function WriteReq(chunk, encoding, cb) {
 
 function WritableState(options, stream) {
   Object.defineProperty(this, 'buffer', {
-    get: deprecate$1(function () {
+    get: deprecate$2(function () {
       return this.getBuffer();
     }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
   });
@@ -36860,7 +36912,7 @@ const decrypt = async function * ({ root, get, key, cache, chunker, hasher }) {
   const { result: nodes } = await cidset.getAllEntries();
   const unwrap = async (eblock) => {
     const { bytes, cid } = await decrypt$1({ ...eblock, key }).catch(e => {
-      console.log('ekey', e);
+      // console.log('ekey', e)
       throw new Error('bad key: ' + key.toString('hex'))
     });
     const block = await createBlock(bytes, cid);
@@ -36981,11 +37033,11 @@ class Valet {
     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)
-      );
+      // 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 => {
@@ -37407,6 +37459,7 @@ class TransactionBlockstore {
     await this.doCommit(innerBlockstore);
     if (doSync) {
       // const all =
+      // console.log('syncing', innerBlockstore.label)
       await Promise.all([...this.syncs].map(async sync => sync.sendUpdate(innerBlockstore).catch(e => {
         console.error('sync error, cancelling', e);
         sync.destroy();
@@ -37519,6 +37572,8 @@ class InnerBlockstore {
 
 const blockOpts = { cache: nocache, chunker: bf(30), codec: codec$1, hasher: sha256$2, compare: simpleCompare };
 
+// const SYNC_ROOT = 'fireproof' // change this if you want to break sync
+
 /**
  * @typedef {import('./blockstore.js').TransactionBlockstore} TransactionBlockstore
  */
@@ -37552,13 +37607,11 @@ const makeGetBlock = blocks => {
 async function createAndSaveNewEvent ({ inBlocks, bigPut, root, event: inEvent, head, additions, removals = [] }) {
   let cids;
   const { key, value, del } = inEvent;
+  // console.log('createAndSaveNewEvent', root.constructor.name, root.entryList)
+  // root = await root.block
   const data = {
     root: root
-      ? {
-          cid: root.cid,
-          bytes: root.bytes, // can we remove this?
-          value: root.value // can we remove this?
-        }
+      ? (await root.address)
       : null,
     key
   };
@@ -37570,6 +37623,29 @@ async function createAndSaveNewEvent ({ inBlocks, bigPut, root, event: inEvent,
     data.value = value;
     data.type = 'put';
   }
+  // console.log('head', head)
+  // if (head.length === 0) {
+  //   // create an empty prolly root
+  //   let emptyRoot
+
+  //   for await (const node of create({ get: getBlock, list: [{ key: '_sync', value: SYNC_ROOT }], ...blockOpts })) {
+  //     emptyRoot = await node.block
+  //     bigPut(emptyRoot)
+  //   }
+  //   console.log('emptyRoot', emptyRoot)
+  //   const first = await EventBlock.create(
+  //     {
+  //       root: emptyRoot.cid,
+  //       key: null,
+  //       value: null,
+  //       type: 'del'
+  //     },
+  //     []
+  //   )
+  //   bigPut(first)
+  //   head = [first.cid]
+  // }
+
   /** @type {import('./clock').EventData} */
   // @ts-ignore
   const event = await EventBlock.create(data, head);
@@ -37638,16 +37714,23 @@ const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
   // console.log('prollyRootFromAncestor', ancestor)
   const event = await events.get(ancestor);
   const { root } = event.value.data;
-  // console.log('prollyRootFromAncestor', root.cid, JSON.stringify(root.value))
   if (root) {
-    return load$2({ cid: root.cid, get: getBlock, ...blockOpts })
+    return load$2({ cid: root, get: getBlock, ...blockOpts })
   } else {
-    return null
+    // console.log('no root', root) // false means no common ancestor. null means empty database.
+    return root
   }
 };
 
+// async function bigMerge (events, head, getBlock) {
+//   const allRoots = await Promise.all(head.map(async h => prollyRootFromAncestor(events, h, getBlock)))
+//   console.log('allRoots', allRoots)
+//   // todo query over all roots and merge them, but how do they not have a common ancestor? they all start with the _sync root
+//   throw new Error('not implemented')
+// }
+
 const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
-  const { getBlock, blocks } = makeGetAndPutBlock(inBlocks);
+  const { getBlock, blocks } = makeGetAndPutBlock(inBlocks); // this is doubled with eventfetcher
   let bulkSorted = [];
   let prollyRootNode = null;
   const events = new EventFetcher(blocks);
@@ -37655,14 +37738,22 @@ const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
     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
+      // 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 {cids, events : bulkSorted } = await findEventsToSync(blocks, head)
       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)
+      // console.log('sorted', !!ancestor, JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
+      if (ancestor) {
+        prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock);
+        // if (!prollyRootNode) {
+        //   prollyRootNode = await bigMerge(events, head, getBlock)
+        //   // throw new Error('no common ancestor')
+        // }
+      }
+      // console.log('event', event)
     }
   }
 
@@ -37670,16 +37761,23 @@ const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
 
   // if prolly root node is null, we need to create a new one
   if (!prollyRootNode) {
+    // console.log('make new root', bulkOperations.length)
     let root;
+    // let rootNode
     const newBlocks = [];
     // if all operations are deletes, we can just return an empty root
     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 })) {
-      root = await node.block;
-      newBlocks.push(root);
+      // root = await node.block
+      root = node;
+      newBlocks.push(await node.block);
     }
+    // throw new Error('not root time')
+    // root.isThisOne = 'yes'
+    // console.log('made new root', root.constructor.name, root.block.cid.toString())
+
     return { root, blocks: newBlocks, clockCIDs: await events.all() }
   } else {
     const writeResp = await prollyRootNode.bulk(bulkOperations); // { root: newProllyRootNode, blocks: newBlocks }
@@ -37699,7 +37797,7 @@ const doProllyBulk = async (inBlocks, head, event, doFull = false) => {
  */
 async function put (inBlocks, head, event, options) {
   const { bigPut } = makeGetAndPutBlock(inBlocks);
-
+  // console.log('major put')
   // If the head is empty, we create a new event and return the root and addition blocks
   if (!head.length) {
     const additions = new Map();
@@ -37731,7 +37829,7 @@ async function put (inBlocks, head, event, options) {
     return createAndSaveNewEvent({
       inBlocks,
       bigPut,
-      root: prollyRootBlock,
+      root: newProllyRootNode, // Block
       event,
       head,
       additions: Array.from(additions.values()) /*, todo? Array.from(removals.values()) */
@@ -37750,20 +37848,25 @@ async function root (inBlocks, head, doFull = false) {
     throw new Error('no 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(
+  return await doTransaction(
     'root',
     inBlocks,
     async transactionBlocks => {
       const { bigPut } = makeGetAndPutBlock(transactionBlocks);
+      const { root: newProllyRootNode, blocks: newBlocks, clockCIDs } = await doProllyBulk(inBlocks, head, null, doFull);
+      //
+      // const rootBlock = await newProllyRootNode.block
+      // bigPut(rootBlock)
       for (const nb of newBlocks) {
         bigPut(nb);
       }
+      // console.log('root root', newProllyRootNode.constructor.name, newProllyRootNode)
+      return { clockCIDs, node: newProllyRootNode }
     },
     false
-  );
-  return { clockCIDs, node: newProllyRootNode }
+  )
+  // return { clockCIDs, node: newProllyRootNode }
 }
 
 /**
@@ -37779,7 +37882,8 @@ async function eventsSince (blocks, head, since) {
     return { clockCIDs: [], result: [] }
   }
   // @ts-ignore
-  const sinceHead = [...since, ...head]; // ?
+  const sinceHead = [...since, ...head].map(h => h.toString()); // ?
+  // console.log('eventsSince', sinceHead.map(h => h.toString()))
   const { cids, events: unknownSorted3 } = await findEventsToSync(blocks, sinceHead);
   return { clockCIDs: cids, result: unknownSorted3.map(({ value: { data } }) => data) }
 }
@@ -37816,8 +37920,12 @@ async function rootOrCache (blocks, head, rootCache, doFull = false) {
     clockCIDs = rootCache.clockCIDs;
   } else {
 ({ node, clockCIDs } = await root(blocks, head, doFull));
+
+    // this.applyClock(prevClock, result.head)
+    // await this.notifyListeners([decodedEvent])
+
     // console.timeEnd(callTag + '.root')
-    // console.log('found root')
+    // console.log('found root', node.entryList)
   }
   return { node, clockCIDs }
 }
@@ -38185,8 +38293,8 @@ class Database {
    * @memberof Fireproof
    * @instance
    */
-  clockToJSON () {
-    return this.clock.map(cid => cid.toString())
+  clockToJSON (clock = null) {
+    return (clock || this.clock).map(cid => cid.toString())
   }
 
   hydrate ({ clock, name, key }) {
@@ -38226,21 +38334,21 @@ class Database {
    * @memberof Fireproof
    * @instance
    */
-  async changesSince (event) {
-    // console.log('events for', this.instanceId, event.constructor.name)
-    // console.log('changesSince', this.instanceId, event, this.clock)
+  async changesSince (aClock) {
+    // console.log('events for', this.instanceId, aClock?.constructor.name)
+    // console.log('changesSince', this.instanceId, this.clockToJSON(aClock), this.clockToJSON())
     let rows, dataCIDs, clockCIDs;
-    // if (!event) event = []
-    if (event) {
-      event = event.map((cid) => cid.toString());
-      const eventKey = JSON.stringify([...event, ...this.clockToJSON()]);
+    // if (!aClock) aClock = []
+    if (aClock && aClock.length > 0) {
+      aClock = aClock.map((cid) => cid.toString());
+      const eventKey = JSON.stringify([...this.clockToJSON(aClock), ...this.clockToJSON()]);
 
       let resp;
       if (this.eventsCache.has(eventKey)) {
-        console.log('events from cache');
+        // console.log('events from cache')
         resp = this.eventsCache.get(eventKey);
       } else {
-        resp = await eventsSince(this.blocks, this.clock, event);
+        resp = await eventsSince(this.blocks, this.clock, aClock);
         this.eventsCache.set(eventKey, resp);
       }
       const docsMap = new Map();
@@ -38401,7 +38509,9 @@ class Database {
    */
   async putToProllyTree (decodedEvent, clock = null) {
     const event = encodeEvent(decodedEvent);
-    if (clock && JSON.stringify(clock) !== JSON.stringify(this.clockToJSON())) {
+    if (clock && JSON.stringify(this.clockToJSON(clock)) !== JSON.stringify(this.clockToJSON())) {
+      // console.log('this.clock', this.clockToJSON())
+      // console.log('that.clock', this.clockToJSON(clock))
       // we need to check and see what version of the document exists at the clock specified
       // if it is the same as the one we are trying to put, then we can proceed
       const resp = await eventsSince(this.blocks, this.clock, event.value._clock);
@@ -38411,6 +38521,7 @@ class Database {
       }
     }
     const prevClock = [...this.clock];
+    // console.log('putToProllyTree', this.clockToJSON(), decodedEvent)
     const result = await doTransaction(
       'putToProllyTree',
       this.blocks,
@@ -39100,7 +39211,7 @@ class DbIndex {
       );
       this.indexByKey = await bulkIndex(blocks, this.indexByKey, oldIndexEntries.concat(indexEntries), dbIndexOpts);
       this.dbHead = result.clock;
-    });
+    }, false /* don't sync transaction -- maybe move this flag to database.indexBlocks? */);
     // todo index subscriptions
     // this.database.notifyExternal('dbIndex')
     // console.timeEnd(callTag + '.doTransactionupdateIndex')
@@ -41055,10 +41166,15 @@ class Sync {
       this.pushBacklogResolve = resolve;
       this.pushBacklogReject = reject;
     });
+    this.isReady = false;
     // this.pushBacklog.then(() => {
     //   // console.log('sync backlog resolved')
     //   this.database.notifyReset()
     // })
+    // this.connected = new Promise((resolve, reject) => {
+    //   this.readyResolve = resolve
+    //   this.readyReject = reject
+    // })
   }
 
   async offer () {
@@ -41107,22 +41223,22 @@ class Sync {
       // console.log('not a car', data.toString())
     }
     if (reader) {
-      console.log('got car');
+      // console.log('got car')
       this.status = 'parking car';
       const blz = new Set();
       for await (const block of reader.blocks()) {
         blz.add(block);
       }
       const roots = await reader.getRoots();
-      console.log(
-        'got car',
-        roots.map(c => c.toString()),
-        this.database.clock.map(c => c.toString())
-      );
-      console.log(
-        'got blocks',
-        [...blz].map(({ cid }) => cid.toString())
-      );
+      // console.log(
+      //   'got car',
+      //   roots.map(c => c.toString()),
+      //   this.database.clock.map(c => c.toString())
+      // )
+      // console.log(
+      //   'got blocks!',
+      //   [...blz].map(({ cid }) => cid.toString())
+      // )
       // @ts-ignore
       reader.entries = reader.blocks;
       await this.database.blocks.commit(
@@ -41161,7 +41277,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
@@ -41170,9 +41286,10 @@ class Sync {
           this.peer.send(JSON.stringify({ ok: true }));
           // this.pushBacklogResolve({ ok: true })
         } else {
-          console.log('do send', carBlock.bytes.length);
+          // console.log('do send diff', carBlock.bytes.length)
           this.status = 'sending diff car';
           this.peer.send(carBlock.bytes);
+          // console.log('sent diff car')
           // this.pushBacklogResolve({ ok: true })
         }
       }
@@ -41186,7 +41303,7 @@ class Sync {
   }
 
   async sendUpdate (blockstore) {
-    if (!this.peer) return
+    if (!this.peer || !this.isReady) return
     // console.log('send update from', this.database.instanceId)
     // todo should send updates since last sync
     const newCar = await blocksToCarBlock(blockstore.lastCid, blockstore);
@@ -41196,6 +41313,7 @@ class Sync {
 
   async startSync () {
     // console.log('start sync', this.peer.initiator)
+    this.isReady = true;
     const allCIDs = await this.database.allStoredCIDs();
     // console.log('allCIDs', allCIDs)
     const reqCidDiff = {