@fireproof/core 0.4.1 → 0.5.1

package/dist/src/fireproof.mjs

@@ -9539,15 +9539,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
@@ -9690,7 +9682,7 @@ var argv = [];
 var version$2 = ''; // empty string to avoid regexp issues
 var versions = {};
 var release = {};
-var config = {};
+var config$1 = {};
 
 function noop$2() {}
 
@@ -9767,7 +9759,7 @@ var browser$1$1 = {
   hrtime: hrtime,
   platform: platform,
   release: release,
-  config: config,
+  config: config$1,
   uptime: uptime
 };
 
@@ -9848,11 +9840,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);
     };
   }
 
@@ -10461,7 +10453,7 @@ var _polyfillNode_util = {
   isBoolean: isBoolean,
   isArray: isArray,
   inspect: inspect,
-  deprecate: deprecate$1,
+  deprecate: deprecate$2,
   format: format,
   debuglog: debuglog,
   promisify: promisify,
@@ -10474,7 +10466,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,
@@ -10662,108 +10654,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 = {};
 
@@ -10893,109 +10876,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$a;
-var hasRequiredBrowser$3;
+  // Default value
+  return state.objectMode ? 16 : 16 * 1024;
+}
+var state = {
+  getHighWaterMark
+};
 
-function requireBrowser$3 () {
-	if (hasRequiredBrowser$3) return browser$a;
-	hasRequiredBrowser$3 = 1;
-	/**
-	 * Module exports.
-	 */
+/**
+ * Module exports.
+ */
 
-	browser$a = deprecate;
+var browser$a = 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$a;
+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;
@@ -11026,12 +10992,12 @@ function require_stream_writable () {
 
 	/*<replacement>*/
 	const internalUtil = {
-	  deprecate: requireBrowser$3()
+	  deprecate: browser$a
 	};
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStreamBrowser();
+	var Stream = streamBrowser;
 	/*</replacement>*/
 
 	const Buffer = require$$0$2.Buffer;
@@ -11042,8 +11008,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,
@@ -12237,7 +12203,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStreamBrowser();
+	var Stream = streamBrowser;
 	/*</replacement>*/
 
 	const Buffer = require$$0$2.Buffer;
@@ -12260,8 +12226,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,
@@ -15627,7 +15593,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.')
   });
@@ -37116,6 +37082,7 @@ const blocksToCarBlock = async (lastCid, blocks) => {
     blocks = Array.from(blocks.entries());
   }
   for (const { cid, bytes } of blocks) {
+    // console.log(cid, bytes)
     size += blockLength({ cid, bytes });
   }
   const buffer = new Uint8Array(size);
@@ -37695,7 +37662,8 @@ async function root (inBlocks, head) {
  */
 async function eventsSince (blocks, head, since) {
   if (!head.length) {
-    throw new Error('no head')
+    // throw new Error('no head')
+    return { clockCIDs: [], result: [] }
   }
   // @ts-ignore
   const sinceHead = [...since, ...head]; // ?
@@ -38133,7 +38101,7 @@ class Database {
       // console.log('change rows', this.instanceId, rows)
     } else {
       const allResp = await getAll(this.blocks, this.clock);
-      rows = allResp.result.map(({ key, value }) => (decodeEvent({ key, value })));
+      rows = allResp.result.map(({ key, value }) => decodeEvent({ key, value }));
       dataCIDs = allResp.cids;
       // console.log('dbdoc rows', this.instanceId, rows)
     }
@@ -38146,7 +38114,9 @@ class Database {
 
   async allDocuments () {
     const allResp = await getAll(this.blocks, this.clock);
-    const rows = allResp.result.map(({ key, value }) => (decodeEvent({ key, value }))).map(({ key, value }) => ({ key, value: { _id: key, ...value } }));
+    const rows = allResp.result
+      .map(({ key, value }) => decodeEvent({ key, value }))
+      .map(({ key, value }) => ({ key, value: { _id: key, ...value } }));
     return {
       rows,
       clock: this.clockToJSON(),
@@ -38154,6 +38124,15 @@ class Database {
     }
   }
 
+  async allCIDs () {
+    const allResp = await getAll(this.blocks, this.clock);
+    const cids = await cidsToProof(allResp.cids);
+    const clockCids = await cidsToProof(allResp.clockCIDs);
+    // console.log('allcids', cids, clockCids)
+    // todo we need to put the clock head as the last block in the encrypted car
+    return [...cids, ...clockCids] // need a single block version of clock head, maybe an encoded block for it
+  }
+
   /**
    * Runs validation on the specified document using the Fireproof instance's configuration. Throws an error if the document is invalid.
    *
@@ -38166,7 +38145,7 @@ class Database {
   async runValidation (doc) {
     if (this.config && this.config.validateChange) {
       const oldDoc = await this.get(doc._id)
-        .then((doc) => doc)
+        .then(doc => doc)
         .catch(() => ({}));
       this.config.validateChange(doc, oldDoc, this.authCtx);
     }
@@ -38201,13 +38180,13 @@ class Database {
     return doc
   }
   /**
- * @typedef {Object} Document
- * @property {string} _id - The ID of the document (required)
- * @property {string} [_proof] - The proof of the document (optional)
- * @property {string} [_clock] - The clock of the document (optional)
- * @property {any} [key: string] - Index signature notation to allow any other unknown fields
- *  * @property {Object.<string, any>} [otherProperties] - Any other unknown properties (optional)
- */
+   * @typedef {Object} Document
+   * @property {string} _id - The ID of the document (required)
+   * @property {string} [_proof] - The proof of the document (optional)
+   * @property {string} [_clock] - The clock of the document (optional)
+   * @property {any} [key: string] - Index signature notation to allow any other unknown fields
+   *  * @property {Object.<string, any>} [otherProperties] - Any other unknown properties (optional)
+   */
 
   /**
    * Adds a new document to the database, or updates an existing document. Returns the ID of the document and the new clock head.
@@ -38262,17 +38241,17 @@ class Database {
         throw new Error('MVCC conflict, document is changed, please reload the document and try again.')
       }
     }
+    const prevClock = [...this.clock];
     const result = await doTransaction(
       'putToProllyTree',
       this.blocks,
-      async (blocks) => await put(blocks, this.clock, event)
+      async blocks => await put(blocks, this.clock, event)
     );
     if (!result) {
       console.error('failed', event);
       throw new Error('failed to put at storage layer')
     }
-    // console.log('new clock head', this.instanceId, result.head.toString())
-    this.clock = result.head; // do we want to do this as a finally block
+    this.applyClock(prevClock, result.head);
     await this.notifyListeners([decodedEvent]); // this type is odd
     return {
       id: decodedEvent.key,
@@ -38282,6 +38261,12 @@ class Database {
     // todo should include additions (or split clock)
   }
 
+  applyClock (prevClock, newClock) {
+    // console.log('applyClock', prevClock, newClock, this.clock)
+    const removedprevCIDs = this.clock.filter(cid => prevClock.indexOf(cid) === -1);
+    this.clock = removedprevCIDs.concat(newClock);
+  }
+
   //   /**
   //    * Advances the clock to the specified event and updates the root CID
   //    *   Will be used by replication
@@ -38340,7 +38325,7 @@ class Database {
 async function cidsToProof (cids) {
   if (!cids || !cids.all) return []
   const all = await cids.all();
-  return [...all].map((cid) => cid.toString())
+  return [...all].map(cid => cid.toString())
 }
 
 function decodeEvent (event) {
@@ -38650,10 +38635,10 @@ const indexEntriesForChanges = (changes, mapFn) => {
   changes.forEach(({ key, value, del }) => {
     if (del || !value) return
     mapFn(makeDoc({ key, value }), (k, v) => {
-      if (typeof v === 'undefined' || typeof k === 'undefined') return
+      if (typeof k === 'undefined') return
       indexEntries.push({
         key: [charwise.encode(k), key],
-        value: v
+        value: v || null
       });
     });
   });
@@ -38671,23 +38656,25 @@ const indexEntriesForChanges = (changes, mapFn) => {
  *
  */
 class DbIndex {
-  constructor (database, mapFn, clock, opts = {}) {
+  constructor (database, name, mapFn, clock = null, opts = {}) {
     this.database = database;
     if (!database.indexBlocks) {
       database.indexBlocks = new TransactionBlockstore(database?.name + '.indexes', database.blocks.valet?.getKeyMaterial());
     }
-    /**
-     * The map function to apply to each entry in the database.
-     * @type {Function}
-     */
-
+    if (typeof name === 'function') {
+      // app is using deprecated API, remove in 0.7
+      opts = clock;
+      clock = mapFn;
+      mapFn = name;
+      name = null;
+    }
     if (typeof mapFn === 'string') {
       this.mapFnString = mapFn;
     } else {
       this.mapFn = mapFn;
       this.mapFnString = mapFn.toString();
     }
-    this.name = opts.name || this.makeName();
+    this.name = name || this.makeName();
     this.indexById = { root: null, cid: null };
     this.indexByKey = { root: null, cid: null };
     this.dbHead = null;
@@ -38737,7 +38724,7 @@ class DbIndex {
 
   static fromJSON (database, { code, clock, name }) {
     // console.log('DbIndex.fromJSON', database.constructor.name, code, clock)
-    return new DbIndex(database, code, clock, { name })
+    return new DbIndex(database, name, code, clock)
   }
 
   /**
@@ -38754,7 +38741,7 @@ class DbIndex {
    * @memberof DbIndex
    * @instance
    */
-  async query (query, update = true) {
+  async query (query = {}, update = true) {
     // const callId = Math.random().toString(36).substring(2, 7)
     // todo pass a root to query a snapshot
     // console.time(callId + '.updateIndex')
@@ -38781,7 +38768,12 @@ class DbIndex {
   async updateIndex (blocks) {
     // todo this could enqueue the request and give fresh ones to all second comers -- right now it gives out stale promises while working
     // what would it do in a world where all indexes provide a database snapshot to query?
-    if (this.updateIndexPromise) return this.updateIndexPromise
+    if (this.updateIndexPromise) {
+      return this.updateIndexPromise.then(() => {
+        this.updateIndexPromise = null;
+        return this.updateIndex(blocks)
+      })
+    }
     this.updateIndexPromise = this.innerUpdateIndex(blocks);
     this.updateIndexPromise.finally(() => { this.updateIndexPromise = null; });
     return this.updateIndexPromise
@@ -38802,7 +38794,7 @@ class DbIndex {
       this.dbHead = result.clock;
       return
     }
-    await doTransaction('updateIndex', inBlocks, async (blocks) => {
+    const didT = await doTransaction('updateIndex', inBlocks, async (blocks) => {
       let oldIndexEntries = [];
       let removeByIdIndexEntries = [];
       await loadIndex(blocks, this.indexById, idIndexOpts);
@@ -38824,6 +38816,7 @@ class DbIndex {
     this.database.notifyExternal('dbIndex');
     // console.timeEnd(callTag + '.doTransactionupdateIndex')
     // console.log(`updateIndex ${callTag} <`, this.instanceId, this.dbHead?.toString(), this.indexByKey.cid?.toString(), this.indexById.cid?.toString())
+    return didT
   }
 }
 
@@ -38866,7 +38859,11 @@ async function bulkIndex (blocks, inIndex, indexEntries, opts) {
 async function loadIndex (blocks, index, indexOpts) {
   if (!index.root) {
     const cid = index.cid;
-    if (!cid) return
+    if (!cid) {
+      // console.log('no cid', index)
+      // throw new Error('cannot load index')
+      return null
+    }
     const { getBlock } = makeGetBlock(blocks);
     index.root = await load({ cid, get: getBlock, ...indexOpts });
   }
@@ -38893,7 +38890,7 @@ async function doIndexQuery (blocks, indexByKey, query = {}) {
   }
 }
 
-const parseCID = cid => typeof cid === 'string' ? CID$1.parse(cid) : cid;
+const parseCID = cid => (typeof cid === 'string' ? CID$1.parse(cid) : cid);
 
 class Fireproof {
   /**
@@ -38924,7 +38921,11 @@ class Fireproof {
   static fromJSON (json, database) {
     database.hydrate({ clock: json.clock.map(c => parseCID(c)), name: json.name, key: json.key });
     if (json.indexes) {
-      for (const { name, code, clock: { byId, byKey, db } } of json.indexes) {
+      for (const {
+        name,
+        code,
+        clock: { byId, byKey, db }
+      } of json.indexes) {
         DbIndex.fromJSON(database, {
           clock: {
             byId: byId ? parseCID(byId) : null,
@@ -38951,14 +38952,14 @@ class Fireproof {
       });
     }
     const snappedDb = this.fromJSON(definition, withBlocks)
-    ;([...database.indexes.values()]).forEach(index => {
+    ;[...database.indexes.values()].forEach(index => {
       snappedDb.indexes.get(index.mapFnString).mapFn = index.mapFn;
     });
     return snappedDb
   }
 
   static async zoom (database, clock) {
-([...database.indexes.values()]).forEach(index => {
+[...database.indexes.values()].forEach(index => {
       index.indexById = { root: null, cid: null };
       index.indexByKey = { root: null, cid: null };
       index.dbHead = null;
@@ -38967,7 +38968,42 @@ class Fireproof {
     await database.notifyReset(); // hmm... indexes should listen to this? might be more complex than worth it. so far this is the only caller
     return database
   }
+
+  // get all the cids
+  // tell valet to make a file
+  static async makeCar (database, key) {
+    const allCIDs = await database.allCIDs();
+    const blocks = database.blocks;
+
+    const rootCid = CID$1.parse(allCIDs[allCIDs.length - 1]);
+    if (typeof key === 'undefined') {
+      key = blocks.valet?.getKeyMaterial();
+    }
+    if (key) {
+      return blocksToEncryptedCarBlock(
+        rootCid,
+        {
+          entries: () => allCIDs.map(cid => ({ cid })),
+          get: async cid => await blocks.get(cid)
+        },
+        key
+      )
+    } else {
+      const carBlocks = await Promise.all(
+        allCIDs.map(async c => {
+          const b = await blocks.get(c);
+          // console.log('block', b)
+          if (typeof b.cid === 'string') { b.cid = CID$1.parse(b.cid); }
+          // if (b.bytes.constructor.name === 'Buffer') console.log('conver vbuff')
+          return b
+        })
+      );
+      return blocksToCarBlock(rootCid, {
+        entries: () => carBlocks
+      })
+    }
+  }
 }
 
-export { Fireproof, DbIndex as Index, Listener };
+export { Database, Fireproof, DbIndex as Index, Listener };
 //# sourceMappingURL=fireproof.mjs.map