@fireproof/core 0.7.0-alpha.4 → 0.7.0-alpha.5

package/dist/src/fireproof.mjs

@@ -3,7 +3,7 @@ import https from 'node:https';
 import zlib from 'node:zlib';
 import Stream$1, { PassThrough as PassThrough$2, pipeline as pipeline$2 } from 'node:stream';
 import { Buffer as Buffer$H } from 'node:buffer';
-import { types, promisify as promisify$1, deprecate as deprecate$3 } from 'node:util';
+import { types, promisify as promisify$1, deprecate as deprecate$2 } from 'node:util';
 import { format as format$2 } from 'node:url';
 import { isIP } from 'node:net';
 import 'node:fs';
@@ -11483,7 +11483,15 @@ var _polyfillNode_events = /*#__PURE__*/Object.freeze({
 
 var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_events);
 
-var streamBrowser = require$$0$1.EventEmitter;
+var streamBrowser;
+var hasRequiredStreamBrowser;
+
+function requireStreamBrowser () {
+	if (hasRequiredStreamBrowser) return streamBrowser;
+	hasRequiredStreamBrowser = 1;
+	streamBrowser = require$$0$1.EventEmitter;
+	return streamBrowser;
+}
 
 // shim for using process in browser
 // based off https://github.com/defunctzombie/node-process/blob/master/browser.js
@@ -11626,7 +11634,7 @@ var argv = [];
 var version$2 = ''; // empty string to avoid regexp issues
 var versions = {};
 var release = {};
-var config$1 = {};
+var config = {};
 
 function noop$3() {}
 
@@ -11703,7 +11711,7 @@ var browser$1$1 = {
   hrtime: hrtime,
   platform: platform,
   release: release,
-  config: config$1,
+  config: config,
   uptime: uptime
 };
 
@@ -11784,11 +11792,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$2(fn, msg) {
+function deprecate$1(fn, msg) {
   // Allow for deprecating things in the process of starting up.
   if (isUndefined(global$1.process)) {
     return function() {
-      return deprecate$2(fn, msg).apply(this, arguments);
+      return deprecate$1(fn, msg).apply(this, arguments);
     };
   }
 
@@ -12397,7 +12405,7 @@ var _polyfillNode_util = {
   isBoolean: isBoolean,
   isArray: isArray,
   inspect: inspect,
-  deprecate: deprecate$2,
+  deprecate: deprecate$1,
   format: format,
   debuglog: debuglog,
   promisify: promisify,
@@ -12410,7 +12418,7 @@ var _polyfillNode_util$1 = /*#__PURE__*/Object.freeze({
   callbackify: callbackify,
   debuglog: debuglog,
   default: _polyfillNode_util,
-  deprecate: deprecate$2,
+  deprecate: deprecate$1,
   format: format,
   inherits: inherits$w,
   inspect: inspect,
@@ -12598,99 +12606,108 @@ function requireBuffer_list () {
 	return buffer_list;
 }
 
-// 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;
-  }
+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;
+	  }
 
-  // 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 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.
+	  if (this._readableState) {
+	    this._readableState.destroyed = true;
+	  }
 
-  const rState = stream._readableState;
-  const wState = stream._writableState;
-  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
+	  // 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;
 }
-var destroy_1 = {
-  destroy,
-  undestroy,
-  errorOrDestroy
-};
 
 var errorsBrowser = {};
 
@@ -12820,92 +12837,109 @@ createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
 createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
 errorsBrowser.codes = codes;
 
-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 state;
+var hasRequiredState;
 
-  // Default value
-  return state.objectMode ? 16 : 16 * 1024;
+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;
 }
-var state = {
-  getHighWaterMark
-};
 
-/**
- * Module exports.
- */
+var browser$b;
+var hasRequiredBrowser$3;
 
-var browser$b = deprecate$1;
+function requireBrowser$3 () {
+	if (hasRequiredBrowser$3) return browser$b;
+	hasRequiredBrowser$3 = 1;
+	/**
+	 * Module exports.
+	 */
 
-/**
- * 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
- */
+	browser$b = deprecate;
 
-function deprecate$1 (fn, msg) {
-  if (config('noDeprecation')) {
-    return fn;
-  }
+	/**
+	 * 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
+	 */
 
-  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);
-  }
+	function deprecate (fn, msg) {
+	  if (config('noDeprecation')) {
+	    return fn;
+	  }
 
-  return deprecated;
-}
+	  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);
+	  }
 
-/**
- * Checks `localStorage` for boolean values for the given `name`.
- *
- * @param {String} name
- * @returns {Boolean}
- * @api private
- */
+	  return deprecated;
+	}
 
-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';
+	/**
+	 * 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;
 }
 
 var _stream_writable;
@@ -12936,12 +12970,12 @@ function require_stream_writable () {
 
 	/*<replacement>*/
 	const internalUtil = {
-	  deprecate: browser$b
+	  deprecate: requireBrowser$3()
 	};
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = streamBrowser;
+	var Stream = requireStreamBrowser();
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -12952,8 +12986,8 @@ function require_stream_writable () {
 	function _isUint8Array(obj) {
 	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 	}
-	const destroyImpl = destroy_1;
-	const _require = state,
+	const destroyImpl = requireDestroy();
+	const _require = requireState(),
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -14147,7 +14181,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = streamBrowser;
+	var Stream = requireStreamBrowser();
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -14170,8 +14204,8 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	const BufferList = requireBuffer_list();
-	const destroyImpl = destroy_1;
-	const _require = state,
+	const destroyImpl = requireDestroy();
+	const _require = requireState(),
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -17537,7 +17571,7 @@ function WriteReq(chunk, encoding, cb) {
 
 function WritableState(options, stream) {
   Object.defineProperty(this, 'buffer', {
-    get: deprecate$2(function () {
+    get: deprecate$1(function () {
       return this.getBuffer();
     }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
   });
@@ -38950,7 +38984,7 @@ class VMemoryBlockstore {
   }
 }
 
-const defaultConfig$2 = {
+const defaultConfig$1 = {
   headerKeyPrefix: 'fp.'
 };
 
@@ -38958,7 +38992,7 @@ const defaultConfig$2 = {
 
 class Browser extends Base {
   constructor (name, config = {}) {
-    super(name, Object.assign({}, defaultConfig$2, config));
+    super(name, Object.assign({}, defaultConfig$1, config));
     this.isBrowser = false;
     try {
       this.isBrowser = window.localStorage && true;
@@ -39015,209 +39049,6 @@ class Browser extends Base {
   }
 }
 
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// resolves . and .. elements in a path array with directory names there
-// must be no slashes, empty elements, or device names (c:\) in the array
-// (so also no leading and trailing slashes - it does not distinguish
-// relative and absolute paths)
-function normalizeArray(parts, allowAboveRoot) {
-  // if the path tries to go above the root, `up` ends up > 0
-  var up = 0;
-  for (var i = parts.length - 1; i >= 0; i--) {
-    var last = parts[i];
-    if (last === '.') {
-      parts.splice(i, 1);
-    } else if (last === '..') {
-      parts.splice(i, 1);
-      up++;
-    } else if (up) {
-      parts.splice(i, 1);
-      up--;
-    }
-  }
-
-  // if the path is allowed to go above the root, restore leading ..s
-  if (allowAboveRoot) {
-    for (; up--; up) {
-      parts.unshift('..');
-    }
-  }
-
-  return parts;
-}
-
-// Split a filename into [root, dir, basename, ext], unix version
-// 'root' is just a slash, or nothing.
-var splitPathRe =
-    /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
-var splitPath = function(filename) {
-  return splitPathRe.exec(filename).slice(1);
-};
-
-// path.normalize(path)
-// posix version
-function normalize(path) {
-  var isPathAbsolute = isAbsolute(path),
-      trailingSlash = substr(path, -1) === '/';
-
-  // Normalize the path
-  path = normalizeArray(filter(path.split('/'), function(p) {
-    return !!p;
-  }), !isPathAbsolute).join('/');
-
-  if (!path && !isPathAbsolute) {
-    path = '.';
-  }
-  if (path && trailingSlash) {
-    path += '/';
-  }
-
-  return (isPathAbsolute ? '/' : '') + path;
-}
-// posix version
-function isAbsolute(path) {
-  return path.charAt(0) === '/';
-}
-
-// posix version
-function join() {
-  var paths = Array.prototype.slice.call(arguments, 0);
-  return normalize(filter(paths, function(p, index) {
-    if (typeof p !== 'string') {
-      throw new TypeError('Arguments to path.join must be strings');
-    }
-    return p;
-  }).join('/'));
-}
-
-function dirname(path) {
-  var result = splitPath(path),
-      root = result[0],
-      dir = result[1];
-
-  if (!root && !dir) {
-    // No dirname whatsoever
-    return '.';
-  }
-
-  if (dir) {
-    // It has a dirname, strip trailing slash
-    dir = dir.substr(0, dir.length - 1);
-  }
-
-  return root + dir;
-}
-function filter (xs, f) {
-    if (xs.filter) return xs.filter(f);
-    var res = [];
-    for (var i = 0; i < xs.length; i++) {
-        if (f(xs[i], i, xs)) res.push(xs[i]);
-    }
-    return res;
-}
-
-// String.prototype.substr - negative index don't work in IE8
-var substr = 'ab'.substr(-1) === 'b' ?
-    function (str, start, len) { return str.substr(start, len) } :
-    function (str, start, len) {
-        if (start < 0) start = str.length + start;
-        return str.substr(start, len);
-    }
-;
-
-function homedir(){
-  return '$HOME'
-}
-
-var fs = {};
-
-const readFileSync = fs.readFileSync;
-
-const defaultConfig$1 = {
-  dataDir: join(homedir(), '.fireproof')
-};
-
-class Filesystem extends Base {
-  constructor (name, config = {}) {
-    const mergedConfig = Object.assign({}, defaultConfig$1, config);
-    // console.log('Filesystem', name, mergedConfig, header)
-    super(name, mergedConfig);
-  }
-
-  async writeCars (cars) {
-    if (this.config.readonly) return
-    const writes = [];
-    for (const { cid, bytes } of cars) {
-      const carFilename = join(this.config.dataDir, this.name, `${cid.toString()}.car`);
-      // console.log('writeCars', carFilename)
-      writes.push(writeSync(carFilename, bytes));
-    }
-    await Promise.all(writes);
-  }
-
-  async readCar (carCid) {
-    const carFilename = join(this.config.dataDir, this.name, `${carCid.toString()}.car`);
-    const got = readFileSync(carFilename);
-    // console.log('readCar', carFilename, got.constructor.name)
-    return got
-  }
-
-  loadHeader (branch = 'main') {
-    const header = loadSync(this.headerFilename(branch));
-    // console.log('fs getHeader', this.headerFilename(), header, typeof header)
-    if (!header) return null
-    return JSON.parse(header)
-  }
-
-  async writeHeader (branch, header) {
-    // console.log('saveHeader', this.isBrowser)
-    if (this.config.readonly) return
-    const pHeader = this.prepareHeader(header);
-    // console.log('writeHeader fs', branch, pHeader)
-    await writeSync(this.headerFilename(branch), pHeader);
-  }
-
-  headerFilename (branch = 'main') {
-    // console.log('headerFilename', this.config.dataDir, this.name)
-    return join(this.config.dataDir, this.name, branch + '.json')
-  }
-}
-
-function loadSync (filename) {
-  try {
-    return readFileSync(filename, 'utf8').toString()
-  } catch (error) {
-    // console.log('error', error)
-    return null
-  }
-}
-
-async function writeSync (fullpath, stringValue) {
-  await fs.promises.mkdir(dirname(fullpath), { recursive: true });
-  // writeFileSync(fullpath, stringValue)
-  await fs.promises.writeFile(fullpath, stringValue);
-}
-
 /**
  * Returns a `Buffer` instance from the given data URI `uri`.
  *
@@ -44155,7 +43986,7 @@ class Body {
 	}
 }
 
-Body.prototype.buffer = deprecate$3(Body.prototype.buffer, 'Please use \'response.arrayBuffer()\' instead of \'response.buffer()\'', 'node-fetch#buffer');
+Body.prototype.buffer = deprecate$2(Body.prototype.buffer, 'Please use \'response.arrayBuffer()\' instead of \'response.buffer()\'', 'node-fetch#buffer');
 
 // In browsers, all properties are enumerable.
 Object.defineProperties(Body.prototype, {
@@ -44165,7 +43996,7 @@ Object.defineProperties(Body.prototype, {
 	blob: {enumerable: true},
 	json: {enumerable: true},
 	text: {enumerable: true},
-	data: {get: deprecate$3(() => {},
+	data: {get: deprecate$2(() => {},
 		'data doesn\'t exist, use json(), text(), arrayBuffer(), or body instead',
 		'https://github.com/node-fetch/node-fetch/issues/1000 (response)')}
 });
@@ -44269,7 +44100,7 @@ const clone = (instance, highWaterMark) => {
 	return body;
 };
 
-const getNonSpecFormDataBoundary = deprecate$3(
+const getNonSpecFormDataBoundary = deprecate$2(
 	body => body.getBoundary(),
 	'form-data doesn\'t follow the spec and requires special treatment. Use alternative package',
 	'https://github.com/node-fetch/node-fetch/issues/1167'
@@ -45186,7 +45017,7 @@ const isRequest = object => {
 	);
 };
 
-const doBadDataWarn = deprecate$3(() => {},
+const doBadDataWarn = deprecate$2(() => {},
 	'.data is not a valid RequestInit property, use .body instead',
 	'https://github.com/node-fetch/node-fetch/issues/1000 (request)');
 
@@ -45941,26 +45772,17 @@ class Rest extends Base {
   }
 }
 
-const FORCE_IDB = typeof process !== 'undefined' && !!process.env?.FORCE_IDB;
-
-/* global window */
-
 const Loader = {
   appropriate: (name, config = {}) => {
-    let isBrowser = false;
-    try {
-      isBrowser = window.localStorage && true;
-    } catch (e) {}
+    if (config.StorageClass) {
+      return new config.StorageClass(name, config)
+    }
 
     if (config.type === 'rest') {
       return new Rest(name, config)
     }
 
-    if (FORCE_IDB || isBrowser) {
-      return new Browser(name, config)
-    } else {
-      return new Filesystem(name, config)
-    }
+    return new Browser(name, config)
   }
 };
 
@@ -50354,7 +50176,7 @@ class Fireproof {
           clock: {
             byId: byId ? parseCID(byId) : null,
             byKey: byKey ? parseCID(byKey) : null,
-            db: (db && db.length > 0) ? db.map(c => parseCID(c)) : null
+            db: db && db.length > 0 ? db.map(c => parseCID(c)) : null
           },
           code,
           name
@@ -50377,7 +50199,9 @@ class Fireproof {
 
     const withBlocks = new Database(database.name);
     withBlocks.blocks = database.blocks;
-    withBlocks.clock = definition.clock;
+    withBlocks.ready.then(() => {
+      withBlocks.clock = definition.clock.map(c => parseCID(c));
+    });
 
     const snappedDb = Fireproof.fromJSON(definition, null, withBlocks)
     ;[...database.indexes.values()].forEach(index => {