@fireproof/core 0.5.12 → 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)
 }
 
@@ -36826,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);
@@ -36947,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 => {
@@ -37373,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();
@@ -37485,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
  */
@@ -37518,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
   };
@@ -37536,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);
@@ -37604,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);
@@ -37621,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)
     }
   }
 
@@ -37636,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 }
@@ -37665,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();
@@ -37697,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()) */
@@ -37716,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 }
 }
 
 /**
@@ -37745,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) }
 }
@@ -37782,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 }
 }
@@ -38151,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 }) {
@@ -38192,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();
@@ -38367,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);
@@ -38377,6 +38521,7 @@ class Database {
       }
     }
     const prevClock = [...this.clock];
+    // console.log('putToProllyTree', this.clockToJSON(), decodedEvent)
     const result = await doTransaction(
       'putToProllyTree',
       this.blocks,
@@ -39066,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')
@@ -41021,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 () {
@@ -41073,6 +41223,7 @@ class Sync {
       // console.log('not a car', data.toString())
     }
     if (reader) {
+      // console.log('got car')
       this.status = 'parking car';
       const blz = new Set();
       for await (const block of reader.blocks()) {
@@ -41085,7 +41236,7 @@ class Sync {
       //   this.database.clock.map(c => c.toString())
       // )
       // console.log(
-      //   'got blocks',
+      //   'got blocks!',
       //   [...blz].map(({ cid }) => cid.toString())
       // )
       // @ts-ignore
@@ -41126,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
@@ -41135,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 })
         }
       }
@@ -41151,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);
@@ -41161,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 = {