@fireproof/core 0.6.3-dev2 → 0.6.5

package/dist/src/fireproof.js

@@ -1,8 +1,5 @@
 'use strict';
 
-var node_fs = require('node:fs');
-var promises = require('node:fs/promises');
-
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
@@ -8146,6 +8143,267 @@ var raw = /*#__PURE__*/Object.freeze({
 	name: name$2
 });
 
+const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+    return (idbProxyableTypes ||
+        (idbProxyableTypes = [
+            IDBDatabase,
+            IDBObjectStore,
+            IDBIndex,
+            IDBCursor,
+            IDBTransaction,
+        ]));
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+    return (cursorAdvanceMethods ||
+        (cursorAdvanceMethods = [
+            IDBCursor.prototype.advance,
+            IDBCursor.prototype.continue,
+            IDBCursor.prototype.continuePrimaryKey,
+        ]));
+}
+const cursorRequestMap = new WeakMap();
+const transactionDoneMap = new WeakMap();
+const transactionStoreNamesMap = new WeakMap();
+const transformCache = new WeakMap();
+const reverseTransformCache = new WeakMap();
+function promisifyRequest(request) {
+    const promise = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            request.removeEventListener('success', success);
+            request.removeEventListener('error', error);
+        };
+        const success = () => {
+            resolve(wrap$1(request.result));
+            unlisten();
+        };
+        const error = () => {
+            reject(request.error);
+            unlisten();
+        };
+        request.addEventListener('success', success);
+        request.addEventListener('error', error);
+    });
+    promise
+        .then((value) => {
+        // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval
+        // (see wrapFunction).
+        if (value instanceof IDBCursor) {
+            cursorRequestMap.set(value, request);
+        }
+        // Catching to avoid "Uncaught Promise exceptions"
+    })
+        .catch(() => { });
+    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
+    // is because we create many promises from a single IDBRequest.
+    reverseTransformCache.set(promise, request);
+    return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+    // Early bail if we've already created a done promise for this transaction.
+    if (transactionDoneMap.has(tx))
+        return;
+    const done = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            tx.removeEventListener('complete', complete);
+            tx.removeEventListener('error', error);
+            tx.removeEventListener('abort', error);
+        };
+        const complete = () => {
+            resolve();
+            unlisten();
+        };
+        const error = () => {
+            reject(tx.error || new DOMException('AbortError', 'AbortError'));
+            unlisten();
+        };
+        tx.addEventListener('complete', complete);
+        tx.addEventListener('error', error);
+        tx.addEventListener('abort', error);
+    });
+    // Cache it for later retrieval.
+    transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+    get(target, prop, receiver) {
+        if (target instanceof IDBTransaction) {
+            // Special handling for transaction.done.
+            if (prop === 'done')
+                return transactionDoneMap.get(target);
+            // Polyfill for objectStoreNames because of Edge.
+            if (prop === 'objectStoreNames') {
+                return target.objectStoreNames || transactionStoreNamesMap.get(target);
+            }
+            // Make tx.store return the only store in the transaction, or undefined if there are many.
+            if (prop === 'store') {
+                return receiver.objectStoreNames[1]
+                    ? undefined
+                    : receiver.objectStore(receiver.objectStoreNames[0]);
+            }
+        }
+        // Else transform whatever we get back.
+        return wrap$1(target[prop]);
+    },
+    set(target, prop, value) {
+        target[prop] = value;
+        return true;
+    },
+    has(target, prop) {
+        if (target instanceof IDBTransaction &&
+            (prop === 'done' || prop === 'store')) {
+            return true;
+        }
+        return prop in target;
+    },
+};
+function replaceTraps(callback) {
+    idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+    // Due to expected object equality (which is enforced by the caching in `wrap`), we
+    // only create one new func per func.
+    // Edge doesn't support objectStoreNames (booo), so we polyfill it here.
+    if (func === IDBDatabase.prototype.transaction &&
+        !('objectStoreNames' in IDBTransaction.prototype)) {
+        return function (storeNames, ...args) {
+            const tx = func.call(unwrap(this), storeNames, ...args);
+            transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
+            return wrap$1(tx);
+        };
+    }
+    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+    // with real promises, so each advance methods returns a new promise for the cursor object, or
+    // undefined if the end of the cursor has been reached.
+    if (getCursorAdvanceMethods().includes(func)) {
+        return function (...args) {
+            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+            // the original object.
+            func.apply(unwrap(this), args);
+            return wrap$1(cursorRequestMap.get(this));
+        };
+    }
+    return function (...args) {
+        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+        // the original object.
+        return wrap$1(func.apply(unwrap(this), args));
+    };
+}
+function transformCachableValue(value) {
+    if (typeof value === 'function')
+        return wrapFunction(value);
+    // This doesn't return, it just creates a 'done' promise for the transaction,
+    // which is later returned for transaction.done (see idbObjectHandler).
+    if (value instanceof IDBTransaction)
+        cacheDonePromiseForTransaction(value);
+    if (instanceOfAny(value, getIdbProxyableTypes()))
+        return new Proxy(value, idbProxyTraps);
+    // Return the same value back if we're not going to transform it.
+    return value;
+}
+function wrap$1(value) {
+    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+    if (value instanceof IDBRequest)
+        return promisifyRequest(value);
+    // If we've already transformed this value before, reuse the transformed value.
+    // This is faster, but it also provides object equality.
+    if (transformCache.has(value))
+        return transformCache.get(value);
+    const newValue = transformCachableValue(value);
+    // Not all types are transformed.
+    // These may be primitive types, so they can't be WeakMap keys.
+    if (newValue !== value) {
+        transformCache.set(value, newValue);
+        reverseTransformCache.set(newValue, value);
+    }
+    return newValue;
+}
+const unwrap = (value) => reverseTransformCache.get(value);
+
+/**
+ * Open a database.
+ *
+ * @param name Name of the database.
+ * @param version Schema version.
+ * @param callbacks Additional callbacks.
+ */
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+    const request = indexedDB.open(name, version);
+    const openPromise = wrap$1(request);
+    if (upgrade) {
+        request.addEventListener('upgradeneeded', (event) => {
+            upgrade(wrap$1(request.result), event.oldVersion, event.newVersion, wrap$1(request.transaction), event);
+        });
+    }
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event.newVersion, event));
+    }
+    openPromise
+        .then((db) => {
+        if (terminated)
+            db.addEventListener('close', () => terminated());
+        if (blocking) {
+            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
+        }
+    })
+        .catch(() => { });
+    return openPromise;
+}
+
+const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+const writeMethods = ['put', 'add', 'delete', 'clear'];
+const cachedMethods = new Map();
+function getMethod(target, prop) {
+    if (!(target instanceof IDBDatabase &&
+        !(prop in target) &&
+        typeof prop === 'string')) {
+        return;
+    }
+    if (cachedMethods.get(prop))
+        return cachedMethods.get(prop);
+    const targetFuncName = prop.replace(/FromIndex$/, '');
+    const useIndex = prop !== targetFuncName;
+    const isWrite = writeMethods.includes(targetFuncName);
+    if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
+        !(isWrite || readMethods.includes(targetFuncName))) {
+        return;
+    }
+    const method = async function (storeName, ...args) {
+        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+        let target = tx.store;
+        if (useIndex)
+            target = target.index(args.shift());
+        // Must reject if op rejects.
+        // If it's a write operation, must reject if tx.done rejects.
+        // Must reject with op rejection first.
+        // Must resolve with op value.
+        // Must handle both promises (no unhandled rejections)
+        return (await Promise.all([
+            target[targetFuncName](...args),
+            isWrite && tx.done,
+        ]))[0];
+    };
+    cachedMethods.set(prop, method);
+    return method;
+}
+replaceTraps((oldTraps) => ({
+    ...oldTraps,
+    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
+}));
+
 var cargoQueueExports = {};
 var cargoQueue$1 = {
   get exports(){ return cargoQueueExports; },
@@ -8187,7 +8445,7 @@ Object.defineProperty(setImmediate$1, "__esModule", {
     value: true
 });
 setImmediate$1.fallback = fallback;
-setImmediate$1.wrap = wrap$1;
+setImmediate$1.wrap = wrap;
 /* istanbul ignore file */
 
 var hasQueueMicrotask = setImmediate$1.hasQueueMicrotask = typeof queueMicrotask === 'function' && queueMicrotask;
@@ -8198,7 +8456,7 @@ function fallback(fn) {
     setTimeout(fn, 0);
 }
 
-function wrap$1(defer) {
+function wrap(defer) {
     return (fn, ...args) => defer(() => fn(...args));
 }
 
@@ -8214,7 +8472,7 @@ if (hasQueueMicrotask) {
     _defer = fallback;
 }
 
-setImmediate$1.default = wrap$1(_defer);
+setImmediate$1.default = wrap(_defer);
 
 var DoublyLinkedListExports = {};
 var DoublyLinkedList = {
@@ -8885,559 +9143,6 @@ function requireWrapAsync () {
 
 var cargoQueue = /*@__PURE__*/getDefaultExportFromCjs(cargoQueueExports);
 
-const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
-
-let idbProxyableTypes;
-let cursorAdvanceMethods;
-// This is a function to prevent it throwing up in node environments.
-function getIdbProxyableTypes() {
-    return (idbProxyableTypes ||
-        (idbProxyableTypes = [
-            IDBDatabase,
-            IDBObjectStore,
-            IDBIndex,
-            IDBCursor,
-            IDBTransaction,
-        ]));
-}
-// This is a function to prevent it throwing up in node environments.
-function getCursorAdvanceMethods() {
-    return (cursorAdvanceMethods ||
-        (cursorAdvanceMethods = [
-            IDBCursor.prototype.advance,
-            IDBCursor.prototype.continue,
-            IDBCursor.prototype.continuePrimaryKey,
-        ]));
-}
-const cursorRequestMap = new WeakMap();
-const transactionDoneMap = new WeakMap();
-const transactionStoreNamesMap = new WeakMap();
-const transformCache = new WeakMap();
-const reverseTransformCache = new WeakMap();
-function promisifyRequest(request) {
-    const promise = new Promise((resolve, reject) => {
-        const unlisten = () => {
-            request.removeEventListener('success', success);
-            request.removeEventListener('error', error);
-        };
-        const success = () => {
-            resolve(wrap(request.result));
-            unlisten();
-        };
-        const error = () => {
-            reject(request.error);
-            unlisten();
-        };
-        request.addEventListener('success', success);
-        request.addEventListener('error', error);
-    });
-    promise
-        .then((value) => {
-        // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval
-        // (see wrapFunction).
-        if (value instanceof IDBCursor) {
-            cursorRequestMap.set(value, request);
-        }
-        // Catching to avoid "Uncaught Promise exceptions"
-    })
-        .catch(() => { });
-    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
-    // is because we create many promises from a single IDBRequest.
-    reverseTransformCache.set(promise, request);
-    return promise;
-}
-function cacheDonePromiseForTransaction(tx) {
-    // Early bail if we've already created a done promise for this transaction.
-    if (transactionDoneMap.has(tx))
-        return;
-    const done = new Promise((resolve, reject) => {
-        const unlisten = () => {
-            tx.removeEventListener('complete', complete);
-            tx.removeEventListener('error', error);
-            tx.removeEventListener('abort', error);
-        };
-        const complete = () => {
-            resolve();
-            unlisten();
-        };
-        const error = () => {
-            reject(tx.error || new DOMException('AbortError', 'AbortError'));
-            unlisten();
-        };
-        tx.addEventListener('complete', complete);
-        tx.addEventListener('error', error);
-        tx.addEventListener('abort', error);
-    });
-    // Cache it for later retrieval.
-    transactionDoneMap.set(tx, done);
-}
-let idbProxyTraps = {
-    get(target, prop, receiver) {
-        if (target instanceof IDBTransaction) {
-            // Special handling for transaction.done.
-            if (prop === 'done')
-                return transactionDoneMap.get(target);
-            // Polyfill for objectStoreNames because of Edge.
-            if (prop === 'objectStoreNames') {
-                return target.objectStoreNames || transactionStoreNamesMap.get(target);
-            }
-            // Make tx.store return the only store in the transaction, or undefined if there are many.
-            if (prop === 'store') {
-                return receiver.objectStoreNames[1]
-                    ? undefined
-                    : receiver.objectStore(receiver.objectStoreNames[0]);
-            }
-        }
-        // Else transform whatever we get back.
-        return wrap(target[prop]);
-    },
-    set(target, prop, value) {
-        target[prop] = value;
-        return true;
-    },
-    has(target, prop) {
-        if (target instanceof IDBTransaction &&
-            (prop === 'done' || prop === 'store')) {
-            return true;
-        }
-        return prop in target;
-    },
-};
-function replaceTraps(callback) {
-    idbProxyTraps = callback(idbProxyTraps);
-}
-function wrapFunction(func) {
-    // Due to expected object equality (which is enforced by the caching in `wrap`), we
-    // only create one new func per func.
-    // Edge doesn't support objectStoreNames (booo), so we polyfill it here.
-    if (func === IDBDatabase.prototype.transaction &&
-        !('objectStoreNames' in IDBTransaction.prototype)) {
-        return function (storeNames, ...args) {
-            const tx = func.call(unwrap(this), storeNames, ...args);
-            transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
-            return wrap(tx);
-        };
-    }
-    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
-    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
-    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
-    // with real promises, so each advance methods returns a new promise for the cursor object, or
-    // undefined if the end of the cursor has been reached.
-    if (getCursorAdvanceMethods().includes(func)) {
-        return function (...args) {
-            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-            // the original object.
-            func.apply(unwrap(this), args);
-            return wrap(cursorRequestMap.get(this));
-        };
-    }
-    return function (...args) {
-        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-        // the original object.
-        return wrap(func.apply(unwrap(this), args));
-    };
-}
-function transformCachableValue(value) {
-    if (typeof value === 'function')
-        return wrapFunction(value);
-    // This doesn't return, it just creates a 'done' promise for the transaction,
-    // which is later returned for transaction.done (see idbObjectHandler).
-    if (value instanceof IDBTransaction)
-        cacheDonePromiseForTransaction(value);
-    if (instanceOfAny(value, getIdbProxyableTypes()))
-        return new Proxy(value, idbProxyTraps);
-    // Return the same value back if we're not going to transform it.
-    return value;
-}
-function wrap(value) {
-    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
-    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
-    if (value instanceof IDBRequest)
-        return promisifyRequest(value);
-    // If we've already transformed this value before, reuse the transformed value.
-    // This is faster, but it also provides object equality.
-    if (transformCache.has(value))
-        return transformCache.get(value);
-    const newValue = transformCachableValue(value);
-    // Not all types are transformed.
-    // These may be primitive types, so they can't be WeakMap keys.
-    if (newValue !== value) {
-        transformCache.set(value, newValue);
-        reverseTransformCache.set(newValue, value);
-    }
-    return newValue;
-}
-const unwrap = (value) => reverseTransformCache.get(value);
-
-/**
- * Open a database.
- *
- * @param name Name of the database.
- * @param version Schema version.
- * @param callbacks Additional callbacks.
- */
-function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
-    const request = indexedDB.open(name, version);
-    const openPromise = wrap(request);
-    if (upgrade) {
-        request.addEventListener('upgradeneeded', (event) => {
-            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
-        });
-    }
-    if (blocked) {
-        request.addEventListener('blocked', (event) => blocked(
-        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
-        event.oldVersion, event.newVersion, event));
-    }
-    openPromise
-        .then((db) => {
-        if (terminated)
-            db.addEventListener('close', () => terminated());
-        if (blocking) {
-            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
-        }
-    })
-        .catch(() => { });
-    return openPromise;
-}
-
-const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
-const writeMethods = ['put', 'add', 'delete', 'clear'];
-const cachedMethods = new Map();
-function getMethod(target, prop) {
-    if (!(target instanceof IDBDatabase &&
-        !(prop in target) &&
-        typeof prop === 'string')) {
-        return;
-    }
-    if (cachedMethods.get(prop))
-        return cachedMethods.get(prop);
-    const targetFuncName = prop.replace(/FromIndex$/, '');
-    const useIndex = prop !== targetFuncName;
-    const isWrite = writeMethods.includes(targetFuncName);
-    if (
-    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
-    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
-        !(isWrite || readMethods.includes(targetFuncName))) {
-        return;
-    }
-    const method = async function (storeName, ...args) {
-        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
-        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
-        let target = tx.store;
-        if (useIndex)
-            target = target.index(args.shift());
-        // Must reject if op rejects.
-        // If it's a write operation, must reject if tx.done rejects.
-        // Must reject with op rejection first.
-        // Must resolve with op value.
-        // Must handle both promises (no unhandled rejections)
-        return (await Promise.all([
-            target[targetFuncName](...args),
-            isWrite && tx.done,
-        ]))[0];
-    };
-    cachedMethods.set(prop, method);
-    return method;
-}
-replaceTraps((oldTraps) => ({
-    ...oldTraps,
-    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
-    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
-}));
-
-// 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'
-}
-
-const defaultConfig = {
-  dataDir: join(homedir(), '.fireproof'),
-  headerKeyPrefix: 'fp.'
-};
-
-const FORCE_IDB = typeof process !== 'undefined' && !!process.env?.FORCE_IDB;
-
-/* global localStorage */
-
-class Loader {
-  constructor (name, keyId, config = defaultConfig) {
-    this.name = name;
-    this.keyId = keyId;
-    this.config = config;
-    this.isBrowser = false;
-    try {
-      this.isBrowser = window.localStorage && true;
-    } catch (e) {}
-  }
-
-  withDB = async (dbWorkFun) => {
-    if (!this.idb) {
-      this.idb = await openDB(`fp.${this.keyId}.${this.name}.valet`, 3, {
-        upgrade (db, oldVersion, newVersion, transaction) {
-          if (oldVersion < 1) {
-            db.createObjectStore('cars');
-          }
-        }
-      });
-    }
-    return await dbWorkFun(this.idb)
-  }
-
-  async writeCars (cars) {
-    // console.log('writeCars', this.config.dataDir, this.name, cars.map(c => c.cid.toString()))
-    // console.log('writeCars', cars.length)
-
-    if (FORCE_IDB || this.isBrowser) {
-      await this.writeCarsIDB(cars);
-    } else {
-      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 writeCarsIDB (cars) {
-    return await this.withDB(async db => {
-      const tx = db.transaction(['cars'], 'readwrite');
-      for (const { cid, bytes, replaces } of cars) {
-        await tx.objectStore('cars').put(bytes, cid.toString());
-        // todo remove old maps
-        if (replaces) {
-          await tx.objectStore('cars').delete(replaces.toString());
-        }
-      }
-      return await tx.done
-    })
-  }
-
-  async readCar (carCid) {
-    if (FORCE_IDB || this.isBrowser) {
-      return await this.readCarIDB(carCid)
-    } else {
-      const carFilename = join(this.config.dataDir, this.name, `${carCid.toString()}.car`);
-      const got = node_fs.readFileSync(carFilename);
-      // console.log('readCar', carFilename, got.constructor.name)
-      return got
-    }
-  }
-
-  async readCarIDB (carCid) {
-    return await this.withDB(async db => {
-      const tx = db.transaction(['cars'], 'readonly');
-      // console.log('getCarReader', carCid)
-      return await tx.objectStore('cars').get(carCid)
-    })
-  }
-
-  getHeader () {
-    if (this.isBrowser) {
-      return localStorage.getItem(this.config.headerKeyPrefix + this.name)
-    } else {
-      return loadSync(this.headerFilename())
-      // return null
-    }
-  }
-
-  async saveHeader (stringValue) {
-    // console.log('saveHeader', this.isBrowser)
-    if (this.isBrowser) {
-      // console.log('localStorage!', this.config.headerKeyPrefix)
-      return localStorage.setItem(this.config.headerKeyPrefix + this.name, stringValue)
-    } else {
-      // console.log('no localStorage', this.config.dataDir, this.name)
-      // console.log('saving clock to', this.headerFilename(), stringValue)
-
-      try {
-        await writeSync(this.headerFilename(), stringValue);
-      } catch (error) {
-        console.log('error', error);
-      }
-
-      // console.log('saved clock to', this.headerFilename())
-    }
-  }
-
-  headerFilename () {
-    // console.log('headerFilename', this.config.dataDir, this.name)
-    return join(this.config.dataDir, this.name, 'header.json')
-  }
-
-  //   async loadData (database, filename) {
-  //     const fullFilePath = join(process.cwd(), filename)
-  //     const readableStream = createReadStream(fullFilePath)
-  //     const parseStream = parse()
-  //     readableStream.pipe(parseStream)
-
-  //     const saveQueue = cargoQueue(async (tasks, callback) => {
-  //       for (const t of tasks) {
-  //         await database.put(t)
-  //       }
-  //       callback()
-  //     })
-
-//     parseStream.on('data', async (data) => {
-//       saveQueue.push(data)
-//     })
-//     let res
-//     const p = new Promise((resolve, reject) => {
-//       res = resolve
-//     })
-//     saveQueue.drain(async (x) => {
-//       res()
-//     })
-//     return p
-//   }
-}
-
-function loadSync (filename) {
-  try {
-    return node_fs.readFileSync(filename, 'utf8').toString()
-  } catch (error) {
-    // console.log('error', error)
-    return null
-  }
-}
-
-async function writeSync (fullpath, stringValue) {
-  await promises.mkdir(dirname(fullpath), { recursive: true });
-  // writeFileSync(fullpath, stringValue)
-  await promises.writeFile(fullpath, stringValue);
-}
-
 var cryptoBrowserify = {};
 
 var inherits$x;
@@ -9958,7 +9663,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
@@ -10101,7 +9814,7 @@ var argv = [];
 var version$2 = ''; // empty string to avoid regexp issues
 var versions = {};
 var release = {};
-var config$1 = {};
+var config = {};
 
 function noop$3() {}
 
@@ -10178,7 +9891,7 @@ var browser$1$1 = {
   hrtime: hrtime,
   platform: platform,
   release: release,
-  config: config$1,
+  config: config,
   uptime: uptime
 };
 
@@ -10259,11 +9972,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);
     };
   }
 
@@ -10872,7 +10585,7 @@ var _polyfillNode_util = {
   isBoolean: isBoolean,
   isArray: isArray,
   inspect: inspect,
-  deprecate: deprecate$2,
+  deprecate: deprecate$1,
   format: format,
   debuglog: debuglog,
   promisify: promisify,
@@ -10885,7 +10598,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,
@@ -11073,99 +10786,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;
-  }
-
-  // we set destroyed to true before firing error callbacks in order
-  // to make it re-entrance safe in case destroy() is called within callbacks
+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;
+	  }
 
-  if (this._readableState) {
-    this._readableState.destroyed = true;
-  }
+	  // 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 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 = {};
 
@@ -11295,92 +11017,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;
+
+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;
+	  // 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;
@@ -11411,12 +11150,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;
@@ -11427,8 +11166,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,
@@ -12622,7 +12361,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = streamBrowser;
+	var Stream = requireStreamBrowser();
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -12645,8 +12384,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,
@@ -16012,7 +15751,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.')
   });
@@ -39807,7 +39546,6 @@ class Valet {
   constructor (name = 'default', keyMaterial) {
     this.name = name;
     this.setKeyMaterial(keyMaterial);
-    this.loader = new Loader(name, this.keyId); // todo send this config.loader, if we ever need it
     this.uploadQueue = cargoQueue(async (tasks, callback) => {
       // console.log(
       //   'queue worker',
@@ -39842,10 +39580,6 @@ class Valet {
     });
   }
 
-  saveHeader (header) {
-    return this.loader.saveHeader(header)
-  }
-
   getKeyMaterial () {
     return this.keyMaterial
   }
@@ -39886,6 +39620,19 @@ class Valet {
     }
   }
 
+  withDB = async dbWorkFun => {
+    if (!this.idb) {
+      this.idb = await openDB(`fp.${this.keyId}.${this.name}.valet`, 3, {
+        upgrade (db, oldVersion, newVersion, transaction) {
+          if (oldVersion < 1) {
+            db.createObjectStore('cars');
+          }
+        }
+      });
+    }
+    return await dbWorkFun(this.idb)
+  }
+
   /**
    * Iterate over all blocks in the store.
    *
@@ -39926,7 +39673,6 @@ class Valet {
         blockHasher: blockOpts$1.hasher,
         blockCodec: blockOpts$1.codec
       });
-      this.valetRoot = indexNode;
     }
 
     const got = await indexNode.get(cid);
@@ -39973,7 +39719,6 @@ class Valet {
    * @param {*} value
    */
   async parkCar (carCid, value, cids) {
-    // const callId = Math.random().toString(36).substring(7)
     // console.log('parkCar', this.instanceId, this.name, carCid, cids)
     const combinedReader = await this.getCombinedReader(carCid);
     const mapNode = await addCidsToCarIndex(
@@ -39986,7 +39731,7 @@ class Valet {
     this.valetRoot = mapNode;
     this.valetRootCid = mapNode.cid;
     // make a block set with all the cids of the map
-    const saveValetBlocks = new VMemoryBlockstore();
+    const saveValetBlocks = new VMemoryBlockstore(); //  todo this blockstore should read from the last valetCid car also
 
     for await (const cidx of mapNode.cids()) {
       const bytes = await combinedReader.get(cidx);
@@ -39999,8 +39744,7 @@ class Valet {
       newValetCidCar = await blocksToCarBlock(this.valetRootCid, saveValetBlocks);
     }
     // console.log('newValetCidCar', this.name, Math.floor(newValetCidCar.bytes.length / 1024))
-    // console.log('writeCars', callId, carCid.toString(), newValetCidCar.cid.toString())
-    await this.loader.writeCars([
+    await this.writeCars([
       {
         cid: carCid,
         bytes: value,
@@ -40016,8 +39760,6 @@ class Valet {
 
     this.valetRootCarCid = newValetCidCar.cid; // goes to clock
 
-    // console.log('wroteCars', callId, carCid.toString(), newValetCidCar.cid.toString())
-
     // console.log('parked car', carCid, value.length, Array.from(cids))
     // upload to web3.storage if we have credentials
     if (this.uploadFunction) {
@@ -40032,13 +39774,29 @@ class Valet {
     }
   }
 
+  async writeCars (cars) {
+    return await this.withDB(async db => {
+      const tx = db.transaction(['cars'], 'readwrite');
+      for (const { cid, bytes, replaces } of cars) {
+        await tx.objectStore('cars').put(bytes, cid.toString());
+        // todo remove old maps
+        if (replaces) {
+          await tx.objectStore('cars').delete(replaces.toString());
+        }
+      }
+      return await tx.done
+    })
+  }
+
   remoteBlockFunction = null
 
   async getCarReader (carCid) {
     carCid = carCid.toString();
-    const carBytes = await this.loader.readCar(carCid);
-    // const callID = Math.random().toString(36).substring(7)
-    // console.log('getCarReader', callID, carCid)
+    const carBytes = await this.withDB(async db => {
+      const tx = db.transaction(['cars'], 'readonly');
+      // console.log('getCarReader', carCid)
+      return await tx.objectStore('cars').get(carCid)
+    });
     const reader = await CarReader.fromBytes(carBytes);
     if (this.keyMaterial) {
       const roots = await reader.getRoots();
@@ -40062,7 +39820,7 @@ class Valet {
 
       // last block is the root ??? todo
       const rootBlock = blocks[blocks.length - 1];
-      // console.log('got reader', callID, carCid)
+
       return {
         root: rootBlock,
         get: async dataCID => {
@@ -40189,8 +39947,6 @@ const blocksFromEncryptedCarBlock = async (cid, get, keyMaterial) => {
 
 const addCidsToCarIndex = async (blockstore, valetRoot, valetRootCid, bulkOperations) => {
   let indexNode;
-  // const callID = Math.random().toString(32).substring(2, 8)
-  // console.log('addCidsToCarIndex', callID, valetRootCid, bulkOperations.length)
   if (valetRootCid) {
     if (valetRoot) {
       indexNode = valetRoot;
@@ -40210,7 +39966,6 @@ const addCidsToCarIndex = async (blockstore, valetRoot, valetRootCid, bulkOperat
     // console.log('adding', key, value)
     await indexNode.set(key, value);
   }
-  // console.log('newCidsToCarIndex', callID, indexNode.cid, bulkOperations.length)
   return indexNode
 };
 
@@ -41163,6 +40918,22 @@ object.factory = function (codec) {
 	exports.type = 'charwise';
 } (charwise));
 
+/* global localStorage */
+let storageSupported = false;
+try {
+  storageSupported = window.localStorage && true;
+} catch (e) {}
+function localGet (key) {
+  if (storageSupported) {
+    return localStorage && localStorage.getItem(key)
+  }
+}
+function localSet (key, value) {
+  if (storageSupported) {
+    return localStorage && localStorage.setItem(key, value)
+  }
+}
+
 // @ts-nocheck
 const parseCID = cid => (typeof cid === 'string' ? CID$1.parse(cid) : cid);
 
@@ -41187,7 +40958,7 @@ class Database {
     this.name = name;
     this.instanceId = `fp.${this.name}.${Math.random().toString(36).substring(2, 7)}`;
     this.blocks = new TransactionBlockstore(name, config.key);
-    this.indexBlocks = new TransactionBlockstore(name ? name + '.indexes' : null, config.key);
+    this.indexBlocks = new TransactionBlockstore(name + '.indexes', config.key);
     this.clock = clock;
     this.config = config;
   }
@@ -41231,7 +41002,7 @@ class Database {
 
   maybeSaveClock () {
     if (this.name && this.blocks.valet) {
-      this.blocks.valet.saveHeader(JSON.stringify(this));
+      localSet('fp.' + this.name, JSON.stringify(this));
     }
   }
 
@@ -41467,7 +41238,6 @@ class Database {
       console.error('failed', event);
       throw new Error('failed to put at storage layer')
     }
-    // await new Promise(resolve => setTimeout(resolve, 10)) // makes concurrent tests work
     this.applyClock(prevClock, result.head);
     await this.notifyListeners([decodedEvent]); // this type is odd
     return {
@@ -41941,12 +41711,21 @@ class DbIndex {
   applyMapFn (mapFn, name) {
     if (typeof mapFn === 'string') {
       this.mapFnString = mapFn;
+      // make a regex that matches strings that only have letters, numbers, and spaces
+      const regex = /^[a-zA-Z0-9 ]+$/;
+      // if the string matches the regex, make a function that returns the value at that key
+      if (regex.test(mapFn)) {
+        this.mapFn = (doc, emit) => {
+          if (doc[mapFn]) emit(doc[mapFn]);
+        };
+        this.includeDocsDefault = true;
+      }
     } else {
       this.mapFn = mapFn;
       this.mapFnString = mapFn.toString();
     }
     const matches = /=>\s*(.*)/.exec(this.mapFnString);
-    this.includeDocsDefault = matches && matches.length > 0;
+    this.includeDocsDefault = this.includeDocsDefault || (matches && matches.length > 0);
     this.name = name || this.makeName();
   }
 
@@ -44329,8 +44108,8 @@ class Fireproof {
   static storage = (name = null, opts = {}) => {
     if (name) {
       opts.name = name;
-      const loader = new Loader(name, opts.loader);
-      const existing = loader.getHeader();
+      // todo this can come from a registry also eg remote database / config, etc
+      const existing = localGet('fp.' + name);
       if (existing) {
         const existingConfig = JSON.parse(existing);
         return Fireproof.fromConfig(name, existingConfig, opts)