@fireproof/core 0.19.99 → 0.19.101

package/index.cjs

@@ -30,6 +30,47 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/types.ts
+function isFalsy(value) {
+  return value === false && value === null && value === void 0;
+}
+function throwFalsy(value) {
+  if (isFalsy(value)) {
+    throw new Error("value is Falsy");
+  }
+  return value;
+}
+function falsyToUndef(value) {
+  if (isFalsy(value)) {
+    return void 0;
+  }
+  return value;
+}
+var PARAM;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    PARAM = /* @__PURE__ */ ((PARAM2) => {
+      PARAM2["SUFFIX"] = "suffix";
+      PARAM2["URL_GEN"] = "urlGen";
+      PARAM2["STORE_KEY"] = "storekey";
+      PARAM2["STORE"] = "store";
+      PARAM2["KEY"] = "key";
+      PARAM2["INDEX"] = "index";
+      PARAM2["NAME"] = "name";
+      PARAM2["VERSION"] = "version";
+      PARAM2["FRAG_SIZE"] = "fragSize";
+      PARAM2["IV_VERIFY"] = "ivVerify";
+      PARAM2["IV_HASH"] = "ivHash";
+      PARAM2["FRAG_FID"] = "fid";
+      PARAM2["FRAG_OFS"] = "ofs";
+      PARAM2["FRAG_LEN"] = "len";
+      PARAM2["FRAG_HEAD"] = "headerSize";
+      return PARAM2;
+    })(PARAM || {});
+  }
+});
+
 // src/utils.ts
 function presetEnv() {
   const penv = new Map([
@@ -87,6 +128,10 @@ function ensureLogger(sthis, componentName, ctx) {
       exposeStack = true;
       delete ctx.exposeStack;
     }
+    if ("exposeStack" in ctx) {
+      exposeStack = true;
+      delete ctx.exposeStack;
+    }
     if ("this" in ctx) {
       cLogger.Str("this", sthis.nextId(4).str);
       delete ctx.this;
@@ -153,10 +198,13 @@ function ensureLogger(sthis, componentName, ctx) {
     logger.SetExposeStack(true);
   }
   const out = cLogger.Logger();
+  if (sthis.env.get("FP_CONSTRUCTOR_DEBUG")) {
+    out.Debug().Msg("constructor");
+  }
   return out;
 }
 function getStore(url, sthis, joiner) {
-  const store = url.getParam("store");
+  const store = url.getParam("store" /* STORE */);
   switch (store) {
     case "data":
     case "wal":
@@ -164,20 +212,21 @@ function getStore(url, sthis, joiner) {
       break;
     default:
       throw sthis.logger.Error().Url(url).Msg(`store not found`).AsError();
+      throw sthis.logger.Error().Url(url).Msg(`store not found`).AsError();
   }
   let name = store;
   if (url.hasParam("index")) {
-    name = joiner(url.getParam("index") || "idx", name);
+    name = joiner(url.getParam("index" /* INDEX */) || "idx", name);
   }
   return { store, name };
 }
 function getKey(url, logger) {
-  const result = url.getParam("key");
+  const result = url.getParam("key" /* KEY */);
   if (!result) throw logger.Error().Str("url", url.toString()).Msg(`key not found`).AsError();
   return result;
 }
 function getName(sthis, url) {
-  let result = url.getParam("name");
+  let result = url.getParam("name" /* NAME */);
   if (!result) {
     result = sthis.pathOps.dirname(url.pathname);
     if (result.length === 0) {
@@ -197,17 +246,6 @@ function isNotFoundError(e) {
   if (e.code === "ENOENT") return true;
   return false;
 }
-function dataDir(sthis, name, base) {
-  if (!base) {
-    if (!(0, import_cement.runtimeFn)().isBrowser) {
-      const home = sthis.env.get("HOME") || "./";
-      base = sthis.env.get("FP_STORAGE_URL") || `file://${sthis.pathOps.join(home, ".fireproof")}`;
-    } else {
-      base = sthis.env.get("FP_STORAGE_URL") || `indexdb://fp`;
-    }
-  }
-  return import_cement.URI.from(base.toString()).build().setParam("name", name || "").URI();
-}
 function UInt8ArrayEqual(a, b) {
   if (a.length !== b.length) {
     return false;
@@ -224,6 +262,7 @@ var init_utils = __esm({
   "src/utils.ts"() {
     "use strict";
     import_cement = require("@adviser/cement");
+    init_types();
     import_base58 = require("multiformats/bases/base58");
     globalLogger = new import_cement.LoggerImpl();
     registerFP_DEBUG = new import_cement.ResolveOnce();
@@ -274,6 +313,9 @@ var init_utils = __esm({
       dirname(path) {
         return path.split("/").slice(0, -1).join("/");
       }
+      basename(path) {
+        return path.split("/").pop() || "";
+      }
       // homedir() {
       //     throw new Error("SysContainer:homedir is not available in seeded state");
       //   }
@@ -292,45 +334,63 @@ var init_utils = __esm({
   }
 });
 
-// src/runtime/gateways/file/mem-filesystem.ts
-var mem_filesystem_exports = {};
-__export(mem_filesystem_exports, {
-  MemFileSystem: () => MemFileSystem
+// src/runtime/gateways/file/deno-filesystem.ts
+var deno_filesystem_exports = {};
+__export(deno_filesystem_exports, {
+  DenoFileSystem: () => DenoFileSystem
 });
-var import_memfs, MemFileSystem;
-var init_mem_filesystem = __esm({
-  "src/runtime/gateways/file/mem-filesystem.ts"() {
+var DenoFileSystem;
+var init_deno_filesystem = __esm({
+  "src/runtime/gateways/file/deno-filesystem.ts"() {
     "use strict";
-    import_memfs = require("memfs");
-    init_utils2();
-    MemFileSystem = class {
+    DenoFileSystem = class {
       async start() {
+        this.fs = Deno;
         return this;
       }
-      mkdir(path, options) {
-        return import_memfs.fs.promises.mkdir(path, options);
+      async mkdir(path, options) {
+        return this.fs?.mkdir(path, options).then(() => path);
       }
-      readdir(path, options) {
-        return import_memfs.fs.promises.readdir(path, options);
+      async readdir(path) {
+        const ret = [];
+        for await (const dirEntry of this.fs.readdir(path)) {
+          ret.push(dirEntry.name);
+        }
+        return ret;
       }
-      rm(path, options) {
-        return import_memfs.fs.promises.rm(path, options);
+      async rm(path, options) {
+        return this.fs?.rm(path, options);
       }
-      copyFile(source, destination) {
-        return import_memfs.fs.promises.copyFile(source, destination);
+      async copyFile(source, destination) {
+        return this.fs?.copyFile(source, destination);
       }
-      async readfile(path, options) {
-        const ret = await import_memfs.fs.promises.readFile(path, options);
-        return toArrayBuffer(ret);
+      async readfile(path) {
+        return this.fs.readFile(path);
       }
-      stat(path) {
-        return import_memfs.fs.promises.stat(path);
+      async stat(path) {
+        const x = await this.fs.stat(path);
+        return {
+          isFile: () => x.isFile,
+          isDirectory: () => x.isDirectory,
+          isBlockDevice: () => !!x.isBlockDevice,
+          isCharacterDevice: () => !!x.isCharDevice,
+          isSymbolicLink: () => !!x.isSymlink,
+          isFIFO: () => !!x.isFifo,
+          isSocket: () => !!x.isSocket,
+          uid: x.uid,
+          gid: x.gid,
+          size: x.size,
+          atime: x.atime,
+          mtime: x.mtime,
+          ctime: x.birthtime,
+          birthtime: x.birthtime
+        };
       }
-      unlink(path) {
-        return import_memfs.fs.promises.unlink(path);
+      async unlink(path) {
+        return this.fs?.unlink(path);
       }
-      writefile(path, data) {
-        return import_memfs.fs.promises.writeFile(path, Buffer.from(data));
+      async writefile(path, data) {
+        return this.fs?.writeFile(path, Buffer.from(data));
       }
     };
   }
@@ -341,12 +401,11 @@ var node_filesystem_exports = {};
 __export(node_filesystem_exports, {
   NodeFileSystem: () => NodeFileSystem
 });
-var import_cement4, NodeFileSystem;
+var NodeFileSystem;
 var init_node_filesystem = __esm({
   "src/runtime/gateways/file/node-filesystem.ts"() {
     "use strict";
     init_utils2();
-    import_cement4 = require("@adviser/cement");
     NodeFileSystem = class {
       async start() {
         this.fs = await import("fs/promises");
@@ -369,15 +428,12 @@ var init_node_filesystem = __esm({
         return toArrayBuffer(ret);
       }
       stat(path) {
-        return this.fs?.stat(path);
+        return this.fs.stat(path);
       }
       async unlink(path) {
         return this.fs?.unlink(path);
       }
       async writefile(path, data) {
-        if ((0, import_cement4.runtimeFn)().isDeno) {
-          return this.fs?.writeFile(path, data);
-        }
         return this.fs?.writeFile(path, Buffer.from(data));
       }
     };
@@ -393,49 +449,34 @@ __export(utils_exports, {
   toArrayBuffer: () => toArrayBuffer
 });
 async function getFileSystem(url) {
-  const name = url.getParam("fs");
-  let fs2;
-  switch (name) {
-    case "mem":
-      {
-        const { MemFileSystem: MemFileSystem2 } = await Promise.resolve().then(() => (init_mem_filesystem(), mem_filesystem_exports));
-        fs2 = new MemFileSystem2();
-      }
-      break;
-    // case 'deno': {
-    //   const { DenoFileSystem } = await import("./deno-filesystem.js");
-    //   fs = new DenoFileSystem();
-    //   break;
-    // }
-    case "node": {
-      const { NodeFileSystem: NodeFileSystem2 } = await Promise.resolve().then(() => (init_node_filesystem(), node_filesystem_exports));
-      fs2 = new NodeFileSystem2();
-      break;
-    }
-    case "sys":
-    default: {
-      return getFileSystem(url.build().setParam("fs", "node").URI());
-    }
+  let fs;
+  if ((0, import_cement4.runtimeFn)().isDeno) {
+    const { DenoFileSystem: DenoFileSystem2 } = await Promise.resolve().then(() => (init_deno_filesystem(), deno_filesystem_exports));
+    fs = new DenoFileSystem2();
+  } else if ((0, import_cement4.runtimeFn)().isNodeIsh) {
+    const { NodeFileSystem: NodeFileSystem2 } = await Promise.resolve().then(() => (init_node_filesystem(), node_filesystem_exports));
+    fs = new NodeFileSystem2();
+  } else {
+    throw new Error("unsupported runtime");
   }
-  return fs2.start();
+  return fs.start();
 }
 function getPath(url, sthis) {
   const basePath = url.pathname;
-  const name = url.getParam("name");
+  const name = url.getParam("name" /* NAME */);
   if (name) {
-    const version = url.getParam("version");
-    if (!version) throw sthis.logger.Error().Url(url).Msg(`version not found`).AsError();
-    return sthis.pathOps.join(basePath, version, name);
+    return sthis.pathOps.join(basePath, name);
   }
   return sthis.pathOps.join(basePath);
 }
 function getFileName(url, sthis) {
-  const key = url.getParam("key");
+  const key = url.getParam("key" /* KEY */);
   if (!key) throw sthis.logger.Error().Url(url).Msg(`key not found`).AsError();
   const res = getStore(url, sthis, (...a) => a.join("-"));
   switch (res.store) {
-    case "data":
-      return sthis.pathOps.join(res.name, key + ".car");
+    case "data": {
+      return sthis.pathOps.join(res.name, key + (url.getParam("suffix" /* SUFFIX */) || ""));
+    }
     case "wal":
     case "meta":
       return sthis.pathOps.join(res.name, key + ".json");
@@ -454,10 +495,13 @@ function toArrayBuffer(buffer) {
   }
   return view;
 }
+var import_cement4;
 var init_utils2 = __esm({
   "src/runtime/gateways/file/utils.ts"() {
     "use strict";
+    import_cement4 = require("@adviser/cement");
     init_utils();
+    init_types();
   }
 });
 
@@ -572,6 +616,40 @@ var init_key_bag_indexdb = __esm({
   }
 });
 
+// src/runtime/key-bag-memory.ts
+var key_bag_memory_exports = {};
+__export(key_bag_memory_exports, {
+  KeyBagProviderMemory: () => KeyBagProviderMemory
+});
+var memoryKeyBag, KeyBagProviderMemory;
+var init_key_bag_memory = __esm({
+  "src/runtime/key-bag-memory.ts"() {
+    "use strict";
+    memoryKeyBag = /* @__PURE__ */ new Map();
+    KeyBagProviderMemory = class {
+      constructor(url, sthis) {
+        this.url = url;
+        this.sthis = sthis;
+      }
+      key(id) {
+        return `${this.url.pathname}/${id}`;
+      }
+      async get(id) {
+        const binKeyItem = memoryKeyBag.get(this.key(id));
+        if (binKeyItem) {
+          const ki = JSON.parse(this.sthis.txt.decode(binKeyItem));
+          return ki;
+        }
+        return void 0;
+      }
+      async set(id, item) {
+        const p = this.sthis.txt.encode(JSON.stringify(item, null, 2));
+        memoryKeyBag.set(this.key(id), p);
+      }
+    };
+  }
+});
+
 // src/runtime/gateways/file/version.ts
 var FILESTORE_VERSION;
 var init_version = __esm({
@@ -587,23 +665,24 @@ __export(gateway_exports, {
   FileGateway: () => FileGateway,
   FileTestStore: () => FileTestStore
 });
-var import_cement11, versionFiles, FileGateway, FileTestStore;
+var import_cement12, versionFiles, FileGateway, FileTestStore;
 var init_gateway = __esm({
   "src/runtime/gateways/file/gateway.ts"() {
     "use strict";
     init_version();
-    import_cement11 = require("@adviser/cement");
+    import_cement12 = require("@adviser/cement");
     init_utils();
     init_utils2();
-    versionFiles = new import_cement11.KeyedResolvOnce();
+    init_types();
+    versionFiles = new import_cement12.KeyedResolvOnce();
     FileGateway = class {
       get fs() {
         if (!this._fs) throw this.logger.Error().Msg("fs not initialized").AsError();
         return this._fs;
       }
       constructor(sthis) {
-        this.sthis = sthis;
-        this.logger = sthis.logger;
+        this.sthis = ensureSuperLog(sthis, "FileGateway", { this: 1 });
+        this.logger = this.sthis.logger;
       }
       async getVersionFromFile(path, logger) {
         return versionFiles.get(path).once(async () => {
@@ -625,34 +704,33 @@ var init_gateway = __esm({
         });
       }
       start(baseURL) {
-        return (0, import_cement11.exception2Result)(async () => {
+        return (0, import_cement12.exception2Result)(async () => {
           this._fs = await getFileSystem(baseURL);
-          await this.fs.start();
           const url = baseURL.build();
-          url.defParam("version", FILESTORE_VERSION);
+          url.defParam("version" /* VERSION */, FILESTORE_VERSION);
           const dbUrl = await this.buildUrl(url.URI(), "dummy");
           const dbdirFile = this.getFilePath(dbUrl.Ok());
           await this.fs.mkdir(this.sthis.pathOps.dirname(dbdirFile), { recursive: true });
           const dbroot = this.sthis.pathOps.dirname(dbdirFile);
           this.logger.Debug().Url(url.URI()).Str("dbroot", dbroot).Msg("start");
-          url.setParam("version", await this.getVersionFromFile(dbroot, this.logger));
+          url.setParam("version" /* VERSION */, await this.getVersionFromFile(dbroot, this.logger));
           return url.URI();
         });
       }
       async buildUrl(baseUrl, key) {
-        return import_cement11.Result.Ok(baseUrl.build().setParam("key", key).URI());
+        return import_cement12.Result.Ok(baseUrl.build().setParam("key" /* KEY */, key).URI());
       }
       async close() {
-        return import_cement11.Result.Ok(void 0);
+        return import_cement12.Result.Ok(void 0);
       }
       // abstract buildUrl(baseUrl: URL, key: string): Promise<Result<URL>>;
       getFilePath(url) {
-        const key = url.getParam("key");
+        const key = url.getParam("key" /* KEY */);
         if (!key) throw this.logger.Error().Url(url).Msg(`key not found`).AsError();
         return this.sthis.pathOps.join(getPath(url, this.sthis), getFileName(url, this.sthis));
       }
       async put(url, body) {
-        return (0, import_cement11.exception2Result)(async () => {
+        return (0, import_cement12.exception2Result)(async () => {
           const file = await this.getFilePath(url);
           this.logger.Debug().Str("url", url.toString()).Str("file", file).Msg("put");
           await this.fs.writefile(file, body);
@@ -662,19 +740,19 @@ var init_gateway = __esm({
         return exceptionWrapper(async () => {
           const file = this.getFilePath(url);
           try {
+            this.logger.Debug().Url(url).Str("file", file).Msg("get");
             const res = await this.fs.readfile(file);
-            this.logger.Debug().Url(url.asURL()).Str("file", file).Msg("get");
-            return import_cement11.Result.Ok(new Uint8Array(res));
+            return import_cement12.Result.Ok(new Uint8Array(res));
           } catch (e) {
             if (isNotFoundError(e)) {
-              return import_cement11.Result.Err(new NotFoundError(`file not found: ${file}`));
+              return import_cement12.Result.Err(new NotFoundError(`file not found: ${file}`));
             }
-            return import_cement11.Result.Err(e);
+            return import_cement12.Result.Err(e);
           }
         });
       }
       async delete(url) {
-        return (0, import_cement11.exception2Result)(async () => {
+        return (0, import_cement12.exception2Result)(async () => {
           await this.fs.unlink(this.getFilePath(url));
         });
       }
@@ -700,7 +778,7 @@ var init_gateway = __esm({
             }
           }
         }
-        return import_cement11.Result.Ok(void 0);
+        return import_cement12.Result.Ok(void 0);
       }
     };
     FileTestStore = class {
@@ -709,7 +787,7 @@ var init_gateway = __esm({
         this.sthis = sthis;
       }
       async get(iurl, key) {
-        const url = iurl.build().setParam("key", key).URI();
+        const url = iurl.build().setParam("key" /* KEY */, key).URI();
         const dbFile = this.sthis.pathOps.join(getPath(url, this.sthis), getFileName(url, this.sthis));
         this.logger.Debug().Url(url).Str("dbFile", dbFile).Msg("get");
         const buffer = await (await getFileSystem(url)).readfile(dbFile);
@@ -737,7 +815,7 @@ __export(gateway_exports2, {
   getIndexDBName: () => getIndexDBName
 });
 function ensureVersion(url) {
-  return url.build().defParam("version", INDEXDB_VERSION).URI();
+  return url.build().defParam("version" /* VERSION */, INDEXDB_VERSION).URI();
 }
 function sanitzeKey(key) {
   if (key.length === 1) {
@@ -758,17 +836,17 @@ async function connectIdb(url, sthis) {
       }
     });
     const found = await db.get("version", "version");
-    const version = ensureVersion(url).getParam("version");
+    const version = ensureVersion(url).getParam("version" /* VERSION */);
     if (!found) {
       await db.put("version", { version }, "version");
     } else if (found.version !== version) {
-      sthis.logger.Warn().Str("url", url.toString()).Str("version", version).Str("found", found.version).Msg("version mismatch");
+      sthis.logger.Warn().Url(url).Str("version", version).Str("found", found.version).Msg("version mismatch");
     }
     return { db, dbName, version, url };
   });
   return {
     ...once,
-    url: url.build().setParam("version", once.version).URI()
+    url: url.build().setParam("version" /* VERSION */, once.version).URI()
   };
 }
 function joinDBName(...names) {
@@ -777,7 +855,7 @@ function joinDBName(...names) {
 function getIndexDBName(iurl, sthis) {
   const url = ensureVersion(iurl);
   const fullDb = url.pathname.replace(/^\/+/, "").replace(/\?.*$/, "");
-  const dbName = url.getParam("name");
+  const dbName = url.getParam("name" /* NAME */);
   if (!dbName) throw sthis.logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
   const result = joinDBName(fullDb, dbName);
   const objStore = getStore(url, sthis, joinDBName).name;
@@ -789,15 +867,16 @@ function getIndexDBName(iurl, sthis) {
     dbName
   };
 }
-var import_idb2, import_cement12, onceIndexDB, IndexDBGateway, IndexDBTestStore;
+var import_idb2, import_cement13, onceIndexDB, IndexDBGateway, IndexDBTestStore;
 var init_gateway2 = __esm({
   "src/runtime/gateways/indexdb/gateway.ts"() {
     "use strict";
     import_idb2 = require("idb");
-    import_cement12 = require("@adviser/cement");
+    import_cement13 = require("@adviser/cement");
     init_version2();
     init_utils();
-    onceIndexDB = new import_cement12.KeyedResolvOnce();
+    init_types();
+    onceIndexDB = new import_cement13.KeyedResolvOnce();
     IndexDBGateway = class {
       constructor(sthis) {
         this._db = {};
@@ -805,7 +884,7 @@ var init_gateway2 = __esm({
         this.sthis = sthis;
       }
       async start(baseURL) {
-        return (0, import_cement12.exception2Result)(async () => {
+        return (0, import_cement13.exception2Result)(async () => {
           this.logger.Debug().Url(baseURL).Msg("starting");
           await this.sthis.start();
           const ic = await connectIdb(baseURL, this.sthis);
@@ -815,10 +894,10 @@ var init_gateway2 = __esm({
         });
       }
       async close() {
-        return import_cement12.Result.Ok(void 0);
+        return import_cement13.Result.Ok(void 0);
       }
       async destroy(baseUrl) {
-        return (0, import_cement12.exception2Result)(async () => {
+        return (0, import_cement13.exception2Result)(async () => {
           const type = getStore(baseUrl, this.sthis, joinDBName).name;
           const idb = this._db;
           const trans = idb.transaction(type, "readwrite");
@@ -834,7 +913,7 @@ var init_gateway2 = __esm({
         });
       }
       buildUrl(baseUrl, key) {
-        return Promise.resolve(import_cement12.Result.Ok(baseUrl.build().setParam("key", key).URI()));
+        return Promise.resolve(import_cement13.Result.Ok(baseUrl.build().setParam("key" /* KEY */, key).URI()));
       }
       async get(url) {
         return exceptionWrapper(async () => {
@@ -845,13 +924,13 @@ var init_gateway2 = __esm({
           const bytes = await tx.objectStore(store).get(sanitzeKey(key));
           await tx.done;
           if (!bytes) {
-            return import_cement12.Result.Err(new NotFoundError(`missing ${key}`));
+            return import_cement13.Result.Err(new NotFoundError(`missing ${key}`));
           }
-          return import_cement12.Result.Ok(bytes);
+          return import_cement13.Result.Ok(bytes);
         });
       }
       async put(url, value) {
-        return (0, import_cement12.exception2Result)(async () => {
+        return (0, import_cement13.exception2Result)(async () => {
           const key = getKey(url, this.logger);
           const store = getStore(url, this.sthis, joinDBName).name;
           this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("putting");
@@ -861,14 +940,14 @@ var init_gateway2 = __esm({
         });
       }
       async delete(url) {
-        return (0, import_cement12.exception2Result)(async () => {
+        return (0, import_cement13.exception2Result)(async () => {
           const key = getKey(url, this.logger);
           const store = getStore(url, this.sthis, joinDBName).name;
           this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("deleting");
           const tx = this._db.transaction([store], "readwrite");
           await tx.objectStore(store).delete(sanitzeKey(key));
           await tx.done;
-          return import_cement12.Result.Ok(void 0);
+          return import_cement13.Result.Ok(void 0);
         });
       }
     };
@@ -896,15 +975,16 @@ var init_gateway2 = __esm({
 var src_exports = {};
 __export(src_exports, {
   CRDT: () => CRDT,
-  Database: () => Database,
+  DatabaseFactory: () => DatabaseFactory,
+  DatabaseShell: () => DatabaseShell,
   Index: () => Index,
   NotFoundError: () => NotFoundError,
   PACKAGE_VERSION: () => PACKAGE_VERSION,
+  PARAM: () => PARAM,
   Result: () => import_cement.Result,
   UInt8ArrayEqual: () => UInt8ArrayEqual,
   blockstore: () => blockstore_exports,
   bs: () => blockstore_exports,
-  dataDir: () => dataDir,
   ensureLogger: () => ensureLogger,
   ensureSuperLog: () => ensureSuperLog,
   ensureSuperThis: () => ensureSuperThis,
@@ -915,16 +995,19 @@ __export(src_exports, {
   getName: () => getName,
   getStore: () => getStore,
   index: () => index,
+  isDatabase: () => isDatabase,
   isFalsy: () => isFalsy,
   isNotFoundError: () => isNotFoundError,
+  keyConfigOpts: () => keyConfigOpts,
   rt: () => runtime_exports,
   runtime: () => runtime_exports,
-  throwFalsy: () => throwFalsy
+  throwFalsy: () => throwFalsy,
+  toStoreURIRuntime: () => toStoreURIRuntime
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/database.ts
-var import_cement16 = require("@adviser/cement");
+var import_cement18 = require("@adviser/cement");
 
 // src/write-queue.ts
 function writeQueue(worker, payload = Infinity, unbounded = false) {
@@ -967,86 +1050,7 @@ function writeQueue(worker, payload = Infinity, unbounded = false) {
 }
 
 // src/crdt.ts
-var import_cement15 = require("@adviser/cement");
-
-// src/runtime/wait-pr-multiformats/block.ts
-var block_exports = {};
-__export(block_exports, {
-  Block: () => Block,
-  create: () => create,
-  createUnsafe: () => createUnsafe,
-  decode: () => decode,
-  encode: () => encode
-});
-var import_multiformats = require("multiformats");
-var import_block = require("multiformats/block");
-var Block = import_block.Block;
-async function decode({
-  bytes,
-  codec: codec3,
-  hasher: hasher7
-}) {
-  if (bytes == null) throw new Error('Missing required argument "bytes"');
-  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
-  const value = await Promise.resolve(codec3.decode(bytes));
-  const hash = await hasher7.digest(bytes);
-  const cid = import_multiformats.CID.create(1, codec3.code, hash);
-  return new import_block.Block({ value, bytes, cid });
-}
-async function encode({
-  value,
-  codec: codec3,
-  hasher: hasher7
-}) {
-  if (typeof value === "undefined") throw new Error('Missing required argument "value"');
-  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
-  const bytes = await Promise.resolve(codec3.encode(value));
-  const hash = await hasher7.digest(bytes);
-  const cid = import_multiformats.CID.create(1, codec3.code, hash);
-  return new import_block.Block({ value, bytes, cid });
-}
-async function create({
-  bytes,
-  cid,
-  hasher: hasher7,
-  codec: codec3
-}) {
-  if (bytes == null) throw new Error('Missing required argument "bytes"');
-  if (hasher7 == null) throw new Error('Missing required argument "hasher"');
-  const value = await Promise.resolve(codec3.decode(bytes));
-  const hash = await hasher7.digest(bytes);
-  if (!import_multiformats.bytes.equals(cid.multihash.bytes, hash.bytes)) {
-    throw new Error("CID hash does not match bytes");
-  }
-  return createUnsafe({
-    bytes,
-    cid,
-    value,
-    codec: codec3
-  });
-}
-async function createUnsafe({
-  bytes,
-  cid,
-  value: maybeValue,
-  codec: codec3
-}) {
-  const value = await Promise.resolve(maybeValue !== void 0 ? maybeValue : codec3?.decode(bytes));
-  if (value === void 0) throw new Error('Missing required argument, must either provide "value" or "codec"');
-  return new Block({
-    cid,
-    bytes,
-    value
-  });
-}
-
-// src/crdt-helpers.ts
-var import_link = require("multiformats/link");
-var import_sha25 = require("multiformats/hashes/sha2");
-var codec = __toESM(require("@ipld/dag-cbor"), 1);
-var import_crdt = require("@web3-storage/pail/crdt");
-var import_clock2 = require("@web3-storage/pail/clock");
-var Batch = __toESM(require("@web3-storage/pail/crdt/batch"), 1);
+var import_cement17 = require("@adviser/cement");
 
 // src/blockstore/index.ts
 var blockstore_exports = {};
@@ -1059,8 +1063,11 @@ __export(blockstore_exports, {
   FragmentGateway: () => FragmentGateway,
   Loader: () => Loader,
   addCryptoKeyToGatewayMetaPayload: () => addCryptoKeyToGatewayMetaPayload,
-  ensureStart: () => ensureStart,
-  getGatewayFromURL: () => getGatewayFromURL,
+  ensureStoreEnDeFile: () => ensureStoreEnDeFile,
+  fileGatewayFactoryItem: () => fileGatewayFactoryItem,
+  getDefaultURI: () => getDefaultURI,
+  getGatewayFactoryItem: () => getGatewayFactoryItem,
+  getStartedGateway: () => getStartedGateway,
   parseCarFile: () => parseCarFile,
   registerStoreProtocol: () => registerStoreProtocol,
   setCryptoKeyFromGatewayMetaPayload: () => setCryptoKeyFromGatewayMetaPayload,
@@ -1075,7 +1082,7 @@ function toCIDBlock(block) {
 }
 
 // src/blockstore/store-factory.ts
-var import_cement13 = require("@adviser/cement");
+var import_cement15 = require("@adviser/cement");
 
 // src/runtime/files.ts
 var files_exports = {};
@@ -1149,261 +1156,26 @@ var UnixFSFileBuilder = class {
 };
 
 // src/blockstore/store.ts
-var import_p_limit2 = __toESM(require("p-limit"), 1);
 var import_dag_json2 = require("@ipld/dag-json");
 var import_cement10 = require("@adviser/cement");
-
-// src/types.ts
-function isFalsy(value) {
-  return value === false && value === null && value === void 0;
-}
-function throwFalsy(value) {
-  if (isFalsy(value)) {
-    throw new Error("value is Falsy");
-  }
-  return value;
-}
-function falsyToUndef(value) {
-  if (isFalsy(value)) {
-    return void 0;
-  }
-  return value;
-}
-
-// src/blockstore/store.ts
+init_types();
 init_utils();
 
-// src/blockstore/loader.ts
-var import_p_limit = __toESM(require("p-limit"), 1);
-var import_car = require("@ipld/car");
-var import_cement7 = require("@adviser/cement");
-
-// src/blockstore/loader-helpers.ts
-var import_sha2 = require("multiformats/hashes/sha2");
-var dagCodec = __toESM(require("@ipld/dag-cbor"), 1);
-async function parseCarFile(reader, logger) {
-  const roots = await reader.getRoots();
-  const header = await reader.get(roots[0]);
-  if (!header) throw logger.Error().Msg("missing header block").AsError();
-  const dec = await decode({ bytes: header.bytes, hasher: import_sha2.sha256, codec: dagCodec });
-  const fpvalue = dec.value;
-  if (fpvalue && !fpvalue.fp) {
-    throw logger.Error().Msg("missing fp").AsError();
-  }
-  return fpvalue.fp;
-}
-
-// src/blockstore/transaction.ts
-var import_block3 = require("@web3-storage/pail/block");
+// src/blockstore/commit-queue.ts
 var import_cement2 = require("@adviser/cement");
-init_utils();
-var CarTransaction = class extends import_block3.MemoryBlockstore {
-  constructor(parent, opts = { add: true, noLoader: false }) {
-    super();
-    if (opts.add) {
-      parent.transactions.add(this);
-    }
-    this.parent = parent;
-  }
-  async get(cid) {
-    return await this.superGet(cid) || falsyToUndef(await this.parent.get(cid));
-  }
-  async superGet(cid) {
-    return super.get(cid);
+var CommitQueue = class {
+  constructor() {
+    this.queue = [];
+    this.processing = false;
+    this._waitIdleItems = /* @__PURE__ */ new Set();
   }
-};
-function defaultedBlockstoreRuntime(sthis, opts, component, ctx) {
-  const logger = ensureLogger(sthis, component, ctx);
-  const store = opts.store || {};
-  return {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    applyMeta: (meta, snap) => {
+  waitIdle() {
+    if (this.queue.length === 0 && !this.processing) {
       return Promise.resolve();
-    },
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    compact: async (blocks) => {
-      return {};
-    },
-    autoCompact: 100,
-    public: false,
-    name: void 0,
-    threshold: 1e3 * 1e3,
-    ...opts,
-    logger,
-    keyBag: opts.keyBag || {},
-    crypto: (0, import_cement2.toCryptoRuntime)(opts.crypto),
-    store,
-    storeRuntime: toStoreRuntime(store, sthis)
-  };
-}
-function blockstoreFactory(sthis, opts) {
-  if (opts.name) {
-    return new EncryptedBlockstore(sthis, opts);
-  } else {
-    return new BaseBlockstore(opts);
-  }
-}
-var BaseBlockstore = class {
-  constructor(ebOpts = {}) {
-    this.transactions = /* @__PURE__ */ new Set();
-    this.sthis = ensureSuperThis(ebOpts);
-    this.ebOpts = defaultedBlockstoreRuntime(this.sthis, ebOpts, "BaseBlockstore");
-    this.logger = this.ebOpts.logger;
-  }
-  // ready: Promise<void>;
-  ready() {
-    return Promise.resolve();
-  }
-  async close() {
-  }
-  async destroy() {
-  }
-  async get(cid) {
-    if (!cid) throw this.logger.Error().Msg("required cid").AsError();
-    for (const f of this.transactions) {
-      const v = await f.superGet(cid);
-      if (v) return v;
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async put(cid, block) {
-    throw this.logger.Error().Msg("use a transaction to put").AsError();
-  }
-  // TransactionMeta
-  async transaction(fn, _opts) {
-    const t = new CarTransaction(this, _opts);
-    const done = await fn(t);
-    this.lastTxMeta = done;
-    return { t, meta: done };
-  }
-  async *entries() {
-    const seen = /* @__PURE__ */ new Set();
-    for (const t of this.transactions) {
-      for await (const blk of t.entries()) {
-        if (seen.has(blk.cid.toString())) continue;
-        seen.add(blk.cid.toString());
-        yield blk;
-      }
-    }
-  }
-};
-var EncryptedBlockstore = class extends BaseBlockstore {
-  constructor(sthis, ebOpts) {
-    super(ebOpts);
-    this.compacting = false;
-    this.logger = ensureLogger(this.sthis, "EncryptedBlockstore");
-    const { name } = ebOpts;
-    if (!name) {
-      throw this.logger.Error().Msg("name required").AsError();
-    }
-    this.name = name;
-    this.loader = new Loader(this.name, ebOpts, sthis);
-  }
-  ready() {
-    return this.loader.ready();
-  }
-  close() {
-    return this.loader.close();
-  }
-  destroy() {
-    return this.loader.destroy();
-  }
-  async get(cid) {
-    const got = await super.get(cid);
-    if (got) return got;
-    if (!this.loader) {
-      return;
-    }
-    return falsyToUndef(await this.loader.getBlock(cid));
-  }
-  async transaction(fn, opts = { noLoader: false }) {
-    const { t, meta: done } = await super.transaction(fn);
-    const cars = await this.loader.commit(t, done, opts);
-    if (this.ebOpts.autoCompact && this.loader.carLog.length > this.ebOpts.autoCompact) {
-      setTimeout(() => void this.compact(), 10);
-    }
-    if (cars) {
-      this.transactions.delete(t);
-      return { meta: done, cars, t };
-    }
-    throw this.logger.Error().Msg("failed to commit car files").AsError();
-  }
-  async getFile(car, cid) {
-    await this.ready();
-    if (!this.loader) throw this.logger.Error().Msg("loader required to get file, database must be named").AsError();
-    const reader = await this.loader.loadFileCar(
-      car
-      /*, isPublic */
-    );
-    const block = await reader.get(cid);
-    if (!block) throw this.logger.Error().Str("cid", cid.toString()).Msg(`Missing block`).AsError();
-    return block.bytes;
-  }
-  async compact() {
-    await this.ready();
-    if (!this.loader) throw this.logger.Error().Msg("loader required to compact").AsError();
-    if (this.loader.carLog.length < 2) return;
-    const compactFn = this.ebOpts.compact || ((blocks) => this.defaultCompact(blocks, this.logger));
-    if (!compactFn || this.compacting) return;
-    const blockLog = new CompactionFetcher(this);
-    this.compacting = true;
-    const meta = await compactFn(blockLog);
-    await this.loader?.commit(blockLog.loggedBlocks, meta, {
-      compact: true,
-      noLoader: true
-    });
-    this.compacting = false;
-  }
-  async defaultCompact(blocks, logger) {
-    if (!this.loader) {
-      throw logger.Error().Msg("no loader").AsError();
-    }
-    if (!this.lastTxMeta) {
-      throw logger.Error().Msg("no lastTxMeta").AsError();
-    }
-    for await (const blk of this.loader.entries(false)) {
-      blocks.loggedBlocks.putSync(blk.cid, blk.bytes);
-    }
-    for (const t of this.transactions) {
-      for await (const blk of t.entries()) {
-        blocks.loggedBlocks.putSync(blk.cid, blk.bytes);
-      }
-    }
-    return this.lastTxMeta;
-  }
-  async *entries() {
-    for await (const blk of this.loader.entries()) {
-      yield blk;
-    }
-  }
-};
-var CompactionFetcher = class {
-  constructor(blocks) {
-    this.blockstore = blocks;
-    this.loggedBlocks = new CarTransaction(blocks);
-  }
-  async get(cid) {
-    const block = await this.blockstore.get(cid);
-    if (block) this.loggedBlocks.putSync(cid, block.bytes);
-    return falsyToUndef(block);
-  }
-};
-
-// src/blockstore/commit-queue.ts
-var import_cement3 = require("@adviser/cement");
-var CommitQueue = class {
-  constructor() {
-    this.queue = [];
-    this.processing = false;
-    this._waitIdleItems = /* @__PURE__ */ new Set();
-  }
-  waitIdle() {
-    if (this.queue.length === 0 && !this.processing) {
-      return Promise.resolve();
-    }
-    const fn = new import_cement3.Future();
-    this._waitIdleItems.add(fn);
-    return fn.asPromise();
+    }
+    const fn = new import_cement2.Future();
+    this._waitIdleItems.add(fn);
+    return fn.asPromise();
   }
   async enqueue(fn) {
     return new Promise((resolve, reject) => {
@@ -1440,1128 +1212,1499 @@ var CommitQueue = class {
   }
 };
 
-// src/runtime/key-bag.ts
-var key_bag_exports = {};
-__export(key_bag_exports, {
-  KeyBag: () => KeyBag,
-  getKeyBag: () => getKeyBag,
-  registerKeyBagProviderFactory: () => registerKeyBagProviderFactory
+// src/runtime/keyed-crypto.ts
+var keyed_crypto_exports = {};
+__export(keyed_crypto_exports, {
+  BlockIvKeyIdCodec: () => BlockIvKeyIdCodec,
+  keyedCryptoFactory: () => keyedCryptoFactory
 });
-var import_cement6 = require("@adviser/cement");
 init_utils();
 var import_base582 = require("multiformats/bases/base58");
-var KeyBag = class {
-  constructor(rt) {
-    this.rt = rt;
-    this._warnOnce = new import_cement6.ResolveOnce();
-    this._seq = new import_cement6.ResolveSeq();
-    this.logger = ensureLogger(rt.sthis, "KeyBag");
-    this.logger.Debug().Msg("KeyBag created");
-  }
-  async subtleKey(key) {
-    const extractable = this.rt.url.getParam("extractKey") === "_deprecated_internal_api";
-    if (extractable) {
-      this._warnOnce.once(
-        () => this.logger.Warn().Msg("extractKey is enabled via _deprecated_internal_api --- handle keys safely!!!")
-      );
-    }
-    return await this.rt.crypto.importKey(
-      "raw",
-      // raw or jwk
-      import_base582.base58btc.decode(key),
-      // hexStringToUint8Array(key), // raw data
-      "AES-GCM",
-      extractable,
-      ["encrypt", "decrypt"]
-    );
-  }
-  async ensureKeyFromUrl(url, keyFactory) {
-    const storeKey = url.getParam("storekey");
-    if (storeKey === "insecure") {
-      return import_cement6.Result.Ok(url);
-    }
-    if (!storeKey) {
-      const keyName = `@${keyFactory()}@`;
-      const ret = await this.getNamedKey(keyName);
-      if (ret.isErr()) {
-        return ret;
-      }
-      const urb = url.build().setParam("storekey", keyName);
-      return import_cement6.Result.Ok(urb.URI());
+var import_sha2 = require("multiformats/hashes/sha2");
+var CBOR = __toESM(require("cborg"), 1);
+init_types();
+var generateIV = {
+  random: {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    calc: async (ko, crypto, data) => {
+      return crypto.randomBytes(ko.ivLength);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    verify: async (ko, crypto, iv, data) => {
+      return true;
     }
-    if (storeKey.startsWith("@") && storeKey.endsWith("@")) {
-      const ret = await this.getNamedKey(storeKey);
-      if (ret.isErr()) {
-        return ret;
+  },
+  hash: {
+    calc: async (ko, crypto, data) => {
+      const hash = await import_sha2.sha256.digest(data);
+      const hashBytes = new Uint8Array(hash.bytes);
+      const hashArray = new Uint8Array(ko.ivLength);
+      for (let i = 0; i < hashBytes.length; i++) {
+        hashArray[i % ko.ivLength] ^= hashBytes[i];
       }
+      return hashArray;
+    },
+    verify: async function(ko, crypto, iv, data) {
+      return ko.url.getParam("ivVerify" /* IV_VERIFY */) !== "disable" && UInt8ArrayEqual(iv, await this.calc(ko, crypto, data));
     }
-    return import_cement6.Result.Ok(url);
   }
-  async toKeyWithFingerPrint(keyStr) {
-    const material = import_base582.base58btc.decode(keyStr);
-    const key = await this.subtleKey(keyStr);
-    const fpr = await this.rt.crypto.digestSHA256(material);
-    return import_cement6.Result.Ok({
-      key,
-      fingerPrint: import_base582.base58btc.encode(new Uint8Array(fpr))
+};
+function getGenerateIVFn(url, opts) {
+  const ivhash = opts.ivCalc || url.getParam("ivHash" /* IV_HASH */) || "hash";
+  return generateIV[ivhash] || generateIV["hash"];
+}
+var BlockIvKeyIdCodec = class {
+  constructor(ko, iv, opts) {
+    this.code = 3147065;
+    this.name = "Fireproof@encrypted-block:aes-gcm";
+    this.ko = ko;
+    this.iv = iv;
+    this.opts = opts || {};
+  }
+  async encode(data) {
+    const calcIv = this.iv || await getGenerateIVFn(this.ko.url, this.opts).calc(this.ko, this.ko.crypto, data);
+    const { iv } = this.ko.algo(calcIv);
+    const fprt = await this.ko.fingerPrint();
+    const keyId = import_base582.base58btc.decode(fprt);
+    this.ko.logger.Debug().Str("fp", fprt).Msg("encode");
+    return CBOR.encode({
+      iv,
+      keyId,
+      data: await this.ko._encrypt({ iv, bytes: data })
     });
   }
-  async setNamedKey(name, key) {
-    return this._seq.add(() => this._setNamedKey(name, key));
+  async decode(abytes) {
+    let bytes;
+    if (abytes instanceof Uint8Array) {
+      bytes = abytes;
+    } else {
+      bytes = new Uint8Array(abytes);
+    }
+    const { iv, keyId, data } = CBOR.decode(bytes);
+    const fprt = await this.ko.fingerPrint();
+    this.ko.logger.Debug().Str("fp", import_base582.base58btc.encode(keyId)).Msg("decode");
+    if (import_base582.base58btc.encode(keyId) !== fprt) {
+      throw this.ko.logger.Error().Str("fp", fprt).Str("keyId", import_base582.base58btc.encode(keyId)).Msg("keyId mismatch").AsError();
+    }
+    const result = await this.ko._decrypt({ iv, bytes: data });
+    if (!this.opts?.noIVVerify && !await getGenerateIVFn(this.ko.url, this.opts).verify(this.ko, this.ko.crypto, iv, result)) {
+      throw this.ko.logger.Error().Msg("iv missmatch").AsError();
+    }
+    return result;
   }
-  // avoid deadlock
-  async _setNamedKey(name, key) {
-    const item = {
-      name,
-      key
+};
+var keyedCrypto = class {
+  constructor(url, key, cyopt, sthis) {
+    this.ivLength = 12;
+    this.isEncrypting = true;
+    this.logger = ensureLogger(sthis, "keyedCrypto");
+    this.crypto = cyopt;
+    this.key = key;
+    this.url = url;
+  }
+  fingerPrint() {
+    return Promise.resolve(this.key.fingerPrint);
+  }
+  codec(iv, opts) {
+    return new BlockIvKeyIdCodec(this, iv, opts);
+  }
+  algo(iv) {
+    return {
+      name: "AES-GCM",
+      iv: iv || this.crypto.randomBytes(this.ivLength),
+      tagLength: 128
     };
-    const bag = await this.rt.getBag();
-    this.logger.Debug().Str("name", name).Msg("setNamedKey");
-    await bag.set(name, item);
-    return await this.toKeyWithFingerPrint(item.key);
   }
-  async getNamedExtractableKey(name, failIfNotFound = false) {
-    const ret = await this.getNamedKey(name, failIfNotFound);
-    if (ret.isErr()) {
-      return ret;
-    }
-    const named = ret.Ok();
-    return import_cement6.Result.Ok({
-      ...named,
-      extract: async () => {
-        const ext = new Uint8Array(await this.rt.crypto.exportKey("raw", named.key));
-        return {
-          key: ext,
-          keyStr: import_base582.base58btc.encode(ext)
-        };
-      }
-    });
+  async _decrypt(data) {
+    this.logger.Debug().Len(data.bytes, "bytes").Len(data.iv, "iv").Str("fp", this.key.fingerPrint).Msg("decrypting");
+    return new Uint8Array(await this.crypto.decrypt(this.algo(data.iv), this.key.key, data.bytes));
   }
-  async getNamedKey(name, failIfNotFound = false) {
-    const id = this.rt.sthis.nextId(4).str;
-    return this._seq.add(async () => {
-      const bag = await this.rt.getBag();
-      const named = await bag.get(name);
-      if (named) {
-        const fpr = await this.toKeyWithFingerPrint(named.key);
-        this.logger.Debug().Str("id", id).Str("name", name).Result("fpr", fpr).Msg("fingerPrint getNamedKey");
-        return fpr;
-      }
-      if (failIfNotFound) {
-        this.logger.Debug().Str("id", id).Str("name", name).Msg("failIfNotFound getNamedKey");
-        return import_cement6.Result.Err(new Error(`Key not found: ${name}`));
-      }
-      const ret = await this._setNamedKey(name, import_base582.base58btc.encode(this.rt.crypto.randomBytes(this.rt.keyLength)));
-      this.logger.Debug().Str("id", id).Str("name", name).Result("fpr", ret).Msg("createKey getNamedKey-post");
-      return ret;
-    });
+  async _encrypt(data) {
+    this.logger.Debug().Len(data.bytes).Str("fp", this.key.fingerPrint).Msg("encrypting");
+    const a = this.algo(data.iv);
+    return new Uint8Array(await this.crypto.encrypt(a, this.key.key, data.bytes));
   }
 };
-var keyBagProviderFactories = new Map(
-  [
-    {
-      protocol: "file:",
-      factory: async (url, sthis) => {
-        const { KeyBagProviderFile: KeyBagProviderFile2 } = await Promise.resolve().then(() => (init_key_bag_file(), key_bag_file_exports));
-        return new KeyBagProviderFile2(url, sthis);
-      }
-    },
-    {
-      protocol: "indexdb:",
-      factory: async (url, sthis) => {
-        const { KeyBagProviderIndexDB: KeyBagProviderIndexDB2 } = await Promise.resolve().then(() => (init_key_bag_indexdb(), key_bag_indexdb_exports));
-        return new KeyBagProviderIndexDB2(url, sthis);
-      }
-    }
-  ].map((i) => [i.protocol, i])
-);
-function registerKeyBagProviderFactory(item) {
-  const protocol = item.protocol.endsWith(":") ? item.protocol : item.protocol + ":";
-  keyBagProviderFactories.set(protocol, {
-    ...item,
-    protocol
-  });
-}
-function defaultKeyBagOpts(sthis, kbo) {
-  if (kbo.keyRuntime) {
-    return kbo.keyRuntime;
+var nullCodec = class {
+  constructor() {
+    this.code = 0;
+    this.name = "Fireproof@unencrypted-block";
   }
-  const logger = ensureLogger(sthis, "KeyBag");
-  let url;
-  if (kbo.url) {
-    url = import_cement6.URI.from(kbo.url);
-    logger.Debug().Url(url).Msg("from opts");
-  } else {
-    let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
-    if ((0, import_cement6.runtimeFn)().isBrowser) {
-      url = import_cement6.URI.from(bagFnameOrUrl || "indexdb://fp-keybag");
-    } else {
-      if (!bagFnameOrUrl) {
-        const home = sthis.env.get("HOME");
-        bagFnameOrUrl = `${home}/.fireproof/keybag`;
-        url = import_cement6.URI.from(`file://${bagFnameOrUrl}`);
-      } else {
-        url = import_cement6.URI.from(bagFnameOrUrl);
-      }
-    }
-    logger.Debug().Url(url).Msg("from env");
+  encode(data) {
+    return data;
   }
-  const kitem = keyBagProviderFactories.get(url.protocol);
-  if (!kitem) {
-    throw logger.Error().Url(url).Msg("unsupported protocol").AsError();
+  decode(data) {
+    return data;
   }
-  const getBag = async () => kitem.factory(url, sthis);
-  if (url.hasParam("masterkey")) {
-    throw logger.Error().Url(url).Msg("masterkey is not supported").AsError();
+};
+var noCrypto = class {
+  constructor(url, cyrt, sthis) {
+    this.ivLength = 0;
+    this.code = 0;
+    this.name = "Fireproof@unencrypted-block";
+    this.isEncrypting = false;
+    this._fingerPrint = "noCrypto:" + Math.random();
+    this.logger = ensureLogger(sthis, "noCrypto");
+    this.crypto = cyrt;
+    this.url = url;
   }
-  return {
-    url,
-    crypto: kbo.crypto || (0, import_cement6.toCryptoRuntime)({}),
-    sthis,
-    logger,
-    keyLength: kbo.keyLength || 16,
-    getBag,
-    id: () => {
-      return url.toString();
-    }
-  };
-}
-var _keyBags = new import_cement6.KeyedResolvOnce();
-async function getKeyBag(sthis, kbo = {}) {
-  await sthis.start();
-  const rt = defaultKeyBagOpts(sthis, kbo);
-  return _keyBags.get(rt.id()).once(async () => new KeyBag(rt));
-}
-
-// src/blockstore/commitor.ts
-var CBW = __toESM(require("@ipld/car/buffer-writer"), 1);
-var import_sha22 = require("multiformats/hashes/sha2");
-var dagCodec2 = __toESM(require("@ipld/dag-cbor"), 1);
-async function encodeCarFile(roots, t, codec3) {
-  let size = 0;
-  const headerSize = CBW.headerLength({ roots });
-  size += headerSize;
-  for (const { cid, bytes } of t.entries()) {
-    size += CBW.blockLength({ cid, bytes });
+  fingerPrint() {
+    return Promise.resolve(this._fingerPrint);
   }
-  const buffer = new Uint8Array(size);
-  const writer = CBW.createWriter(buffer, { headerSize });
-  for (const r of roots) {
-    writer.addRoot(r);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  codec(iv) {
+    return new nullCodec();
   }
-  for (const { cid, bytes } of t.entries()) {
-    writer.write({ cid, bytes });
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  algo(iv) {
+    return {
+      name: "noCrypto",
+      iv: new Uint8Array(),
+      tagLength: 0
+    };
   }
-  writer.close();
-  return await encode({ value: writer.bytes, hasher: import_sha22.sha256, codec: codec3 });
-}
-async function createCarFile(encoder, cid, t) {
-  return encodeCarFile([cid], t, encoder);
-}
-async function commitFiles(fileStore, walStore, t, done) {
-  const { files: roots } = makeFileCarHeader(done);
-  const cids = [];
-  const codec3 = (await fileStore.keyedCrypto()).codec();
-  const cars = await prepareCarFilesFiles(codec3, roots, t);
-  for (const car of cars) {
-    const { cid, bytes } = car;
-    await fileStore.save({ cid, bytes });
-    await walStore.enqueueFile(
-      cid
-      /*, !!opts.public*/
-    );
-    cids.push(cid);
+  _decrypt() {
+    throw this.logger.Error().Msg("noCrypto.decrypt not implemented").AsError();
   }
-  return cids;
-}
-function makeFileCarHeader(result) {
-  const files = [];
-  for (const [, meta] of Object.entries(result.files || {})) {
-    if (meta && typeof meta === "object" && "cid" in meta && meta !== null) {
-      files.push(meta.cid);
+  _encrypt() {
+    throw this.logger.Error().Msg("noCrypto.decrypt not implemented").AsError();
+  }
+};
+async function keyedCryptoFactory(url, kb, sthis) {
+  const storekey = url.getParam("storekey" /* STORE_KEY */);
+  if (storekey && storekey !== "insecure") {
+    let rkey = await kb.getNamedKey(storekey, true);
+    if (rkey.isErr()) {
+      try {
+        rkey = await kb.toKeyWithFingerPrint(storekey);
+      } catch (e) {
+        throw sthis.logger.Error().Err(e).Str("keybag", kb.rt.id()).Str("name", storekey).Msg("getNamedKey failed").AsError();
+      }
     }
+    return new keyedCrypto(url, rkey.Ok(), kb.rt.crypto, sthis);
   }
-  return { ...result, files };
-}
-async function prepareCarFilesFiles(encoder, roots, t) {
-  return [await encodeCarFile(roots, t, encoder)];
-}
-function makeCarHeader(meta, cars, compact = false) {
-  const coreHeader = compact ? { cars: [], compact: cars } : { cars, compact: [] };
-  return { ...coreHeader, meta };
-}
-async function encodeCarHeader(fp) {
-  return await encode({
-    value: { fp },
-    hasher: import_sha22.sha256,
-    codec: dagCodec2
-  });
+  return new noCrypto(url, kb.rt.crypto, sthis);
 }
-async function commit(params, t, done, opts = { noLoader: false, compact: false }) {
-  const fp = makeCarHeader(done, params.carLog, !!opts.compact);
-  const rootBlock = await encodeCarHeader(fp);
-  const cars = await prepareCarFiles(params.encoder, params.threshold, rootBlock, t);
-  const cids = [];
-  for (const car of cars) {
-    const { cid, bytes } = car;
-    await params.carStore.save({ cid, bytes });
-    cids.push(cid);
+
+// src/blockstore/fragment-gateway.ts
+var import_cement3 = require("@adviser/cement");
+var import_base583 = require("multiformats/bases/base58");
+var import_cborg = require("cborg");
+init_types();
+init_utils();
+function getFragSize(url) {
+  const fragSize = url.getParam("fragSize" /* FRAG_SIZE */);
+  let ret = 0;
+  if (fragSize) {
+    ret = parseInt(fragSize);
   }
-  const newDbMeta = { cars: cids };
-  await params.WALStore.enqueue(newDbMeta, opts);
-  await params.metaStore.save(newDbMeta);
-  return { cgrp: cids, header: fp };
+  if (isNaN(ret) || ret <= 0) {
+    ret = 0;
+  }
+  return ret;
 }
-async function prepareCarFiles(encoder, threshold, rootBlock, t) {
-  const carFiles = [];
-  threshold = threshold || 128e3 * 8;
-  let clonedt = new CarTransaction(t.parent, { add: false, noLoader: false });
-  clonedt.putSync(rootBlock.cid, rootBlock.bytes);
-  let newsize = CBW.blockLength(toCIDBlock(rootBlock));
-  let cidRootBlock = rootBlock;
-  for (const { cid, bytes } of t.entries()) {
-    newsize += CBW.blockLength(toCIDBlock({ cid, bytes }));
-    if (newsize >= threshold) {
-      carFiles.push(await createCarFile(encoder, cidRootBlock.cid, clonedt));
-      clonedt = new CarTransaction(t.parent, { add: false, noLoader: false });
-      clonedt.putSync(cid, bytes);
-      cidRootBlock = { cid, bytes };
-      newsize = CBW.blockLength(toCIDBlock({ cid, bytes }));
-    } else {
-      clonedt.putSync(cid, bytes);
+async function getFrags(url, innerGW, headerSize, logger) {
+  const fragSize = getFragSize(url);
+  if (!fragSize) {
+    const res = await innerGW.get(url);
+    if (res.isErr()) {
+      return [res];
     }
+    const data = res.unwrap();
+    return [
+      import_cement3.Result.Ok({
+        fid: new Uint8Array(0),
+        ofs: 0,
+        len: data.length,
+        data
+      })
+    ];
   }
-  carFiles.push(await createCarFile(encoder, cidRootBlock.cid, clonedt));
-  return carFiles;
+  const firstRaw = await innerGW.get(url.build().setParam("ofs", "0").URI());
+  if (firstRaw.isErr()) {
+    return [firstRaw];
+  }
+  const firstFragment = (0, import_cborg.decode)(firstRaw.unwrap());
+  const blockSize = firstFragment.data.length;
+  const ops = [Promise.resolve(import_cement3.Result.Ok(firstFragment))];
+  const fidStr = import_base583.base58btc.encode(firstFragment.fid);
+  const fragUrl = url.build().setParam("fid" /* FRAG_FID */, fidStr).setParam("len" /* FRAG_LEN */, firstFragment.len.toString()).setParam("headerSize" /* FRAG_HEAD */, headerSize.toString());
+  for (let ofs = blockSize; ofs < firstFragment.len; ofs += blockSize) {
+    ops.push(
+      (async (furl, ofs2) => {
+        const raw2 = await innerGW.get(furl);
+        if (raw2.isErr()) {
+          return raw2;
+        }
+        const fragment = (0, import_cborg.decode)(raw2.unwrap());
+        if (import_base583.base58btc.encode(fragment.fid) !== fidStr) {
+          return import_cement3.Result.Err(logger.Error().Msg("Fragment fid mismatch").AsError());
+        }
+        if (fragment.ofs !== ofs2) {
+          return import_cement3.Result.Err(logger.Error().Uint64("ofs", ofs2).Msg("Fragment ofs mismatch").AsError());
+        }
+        return import_cement3.Result.Ok(fragment);
+      })(fragUrl.setParam("ofs", ofs.toString()).URI(), ofs)
+    );
+  }
+  return Promise.all(ops);
 }
-
-// src/blockstore/loader.ts
-var import_sha23 = require("multiformats/hashes/sha2");
-
-// src/blockstore/task-manager.ts
-init_utils();
-var TaskManager = class {
-  constructor(sthis, callback) {
-    this.eventsWeHandled = /* @__PURE__ */ new Set();
-    this.queue = [];
-    this.isProcessing = false;
-    this.logger = ensureLogger(sthis, "TaskManager");
-    this.callback = callback;
+var FragmentGateway = class {
+  constructor(sthis, innerGW) {
+    this.fidLength = 4;
+    this.headerSize = 32;
+    this.sthis = ensureSuperLog(sthis, "FragmentGateway");
+    this.logger = this.sthis.logger;
+    this.innerGW = innerGW;
   }
-  async handleEvent(cid, parents, dbMeta) {
-    for (const parent of parents) {
-      this.eventsWeHandled.add(parent.toString());
+  slicer(url, body) {
+    const fragSize = getFragSize(url);
+    if (!fragSize) {
+      return [this.innerGW.put(url, body)];
     }
-    this.queue.push({ cid: cid.toString(), dbMeta, retries: 0 });
-    this.queue = this.queue.filter(({ cid: cid2 }) => !this.eventsWeHandled.has(cid2));
-    void this.processQueue();
-  }
-  async processQueue() {
-    if (this.isProcessing) return;
-    this.isProcessing = true;
-    const filteredQueue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
-    const first = filteredQueue[0];
-    if (!first) {
-      return;
+    const blocksize = fragSize - this.headerSize;
+    if (blocksize <= 0) {
+      throw this.logger.Error().Uint64("fragSize" /* FRAG_SIZE */, fragSize).Uint64("headerSize" /* FRAG_HEAD */, this.headerSize).Msg("Fragment size is too small").AsError();
     }
-    try {
-      await this.callback(first.dbMeta);
-      this.eventsWeHandled.add(first.cid);
-      this.queue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
-    } catch (err) {
-      if (first.retries++ > 3) {
-        this.logger.Error().Str("cid", first.cid).Msg("failed to process event block after 3 retries");
-        this.queue = this.queue.filter(({ cid }) => cid !== first.cid);
-      }
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      throw this.logger.Error().Err(err).Msg("failed to process event block").AsError();
-    } finally {
-      this.isProcessing = false;
-      if (this.queue.length > 0) {
-        void this.processQueue();
+    const ops = [];
+    const fid = this.sthis.nextId(this.fidLength);
+    const fragUrl = url.build().setParam("fid" /* FRAG_FID */, fid.str).setParam("len" /* FRAG_LEN */, body.length.toString()).setParam("headerSize" /* FRAG_HEAD */, this.headerSize.toString());
+    for (let ofs = 0; ofs < body.length; ofs += blocksize) {
+      const block = (0, import_cborg.encode)({
+        fid: fid.bin,
+        ofs,
+        len: body.length,
+        data: body.slice(ofs, ofs + blocksize)
+      });
+      if (block.length > fragSize) {
+        throw this.logger.Error().Uint64("block", block.length).Uint64("fragSize", fragSize).Msg("Block size to big").AsError();
       }
+      ops.push(this.innerGW.put(fragUrl.setParam("ofs", ofs.toString()).URI(), block));
     }
+    return ops;
   }
-};
-
-// src/blockstore/loader.ts
-function carLogIncludesGroup(list, cids) {
-  return list.some((arr) => {
-    return arr.toString() === cids.toString();
-  });
-}
-function uniqueCids(list, remove = /* @__PURE__ */ new Set()) {
-  const byString = /* @__PURE__ */ new Map();
-  for (const cid of list) {
-    if (remove.has(cid.toString())) continue;
-    byString.set(cid.toString(), cid);
-  }
-  return [...byString.values()];
-}
-var Loader = class {
-  constructor(name, ebOpts, sthis) {
-    this.commitQueue = new CommitQueue();
-    this.isCompacting = false;
-    this.carReaders = /* @__PURE__ */ new Map();
-    this.seenCompacted = /* @__PURE__ */ new Set();
-    this.processedCars = /* @__PURE__ */ new Set();
-    this.carLog = [];
-    this.getBlockCache = /* @__PURE__ */ new Map();
-    this.seenMeta = /* @__PURE__ */ new Set();
-    this.writeLimit = (0, import_p_limit.default)(1);
-    this.onceReady = new import_cement7.ResolveOnce();
-    this.name = name;
-    this.sthis = sthis;
-    this.ebOpts = defaultedBlockstoreRuntime(
-      sthis,
-      {
-        ...ebOpts,
-        name
-      },
-      "Loader"
-    );
-    this.logger = this.ebOpts.logger;
-    this.taskManager = new TaskManager(sthis, async (dbMeta) => {
-      await this.handleDbMetasFromStore([dbMeta]);
-    });
-  }
-  // readonly id = uuidv4();
-  async keyBag() {
-    return getKeyBag(this.sthis, this.ebOpts.keyBag);
+  buildUrl(baseUrl, key) {
+    return this.innerGW.buildUrl(baseUrl, key);
   }
-  async carStore() {
-    return this.ebOpts.storeRuntime.makeDataStore(this);
+  async destroy(iurl) {
+    return this.innerGW.destroy(iurl);
   }
-  async fileStore() {
-    return this.ebOpts.storeRuntime.makeDataStore(this);
+  async start(url) {
+    this.headerSize = (0, import_cborg.encode)({
+      fid: this.sthis.nextId(this.fidLength).bin,
+      ofs: 1024 * 1024,
+      // 32bit
+      len: 16 * 1024 * 1024,
+      // 32bit
+      data: new Uint8Array(1024)
+    }).length - 1024;
+    return this.innerGW.start(url);
   }
-  async WALStore() {
-    return this.ebOpts.storeRuntime.makeWALStore(this);
+  async close(url) {
+    return this.innerGW.close(url);
   }
-  async metaStore() {
-    return this.ebOpts.storeRuntime.makeMetaStore(this);
+  async put(url, body) {
+    await Promise.all(this.slicer(url, body));
+    return import_cement3.Result.Ok(void 0);
   }
-  async ready() {
-    return this.onceReady.once(async () => {
-      const metas = await (await this.metaStore()).load();
-      if (this.ebOpts.meta) {
-        await this.handleDbMetasFromStore([this.ebOpts.meta]);
-      } else if (metas) {
-        await this.handleDbMetasFromStore(metas);
+  async get(url) {
+    const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
+    let buffer = void 0;
+    for (const rfrag of rfrags) {
+      if (rfrag.isErr()) {
+        return import_cement3.Result.Err(rfrag.Err());
       }
-    });
-  }
-  async close() {
-    const toClose = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.WALStore()]);
-    await Promise.all(toClose.map((store) => store.close()));
-  }
-  async destroy() {
-    const toDestroy = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.WALStore()]);
-    await Promise.all(toDestroy.map((store) => store.destroy()));
-  }
-  // async snapToCar(carCid: AnyLink | string) {
-  //   await this.ready
-  //   if (typeof carCid === 'string') {
-  //     carCid = CID.parse(carCid)
-  //   }
-  //   const carHeader = await this.loadCarHeaderFromMeta({ car: carCid, key: this.key || null })
-  //   this.carLog = [carCid, ...carHeader.cars]
-  //   await this.getMoreReaders(carHeader.cars)
-  //   await this._applyCarHeader(carHeader, true)
-  // }
-  async handleDbMetasFromStore(metas) {
-    this.logger.Debug().Any("metas", metas).Msg("handleDbMetasFromStore");
-    for (const meta of metas) {
-      await this.writeLimit(async () => {
-        await this.mergeDbMetaIntoClock(meta);
-      });
+      const frag = rfrag.Ok();
+      buffer = buffer || new Uint8Array(frag.len);
+      buffer.set(frag.data, frag.ofs);
     }
+    return import_cement3.Result.Ok(buffer || new Uint8Array(0));
   }
-  async mergeDbMetaIntoClock(meta) {
-    if (this.isCompacting) {
-      throw this.logger.Error().Msg("cannot merge while compacting").AsError();
+  async subscribe(url, callback) {
+    if (this.innerGW.subscribe) {
+      return this.innerGW.subscribe(url, callback);
+    } else {
+      return import_cement3.Result.Err(this.logger.Error().Url(url).Msg("subscribe not supported").AsError());
     }
-    if (this.seenMeta.has(meta.cars.toString())) return;
-    this.seenMeta.add(meta.cars.toString());
-    if (carLogIncludesGroup(this.carLog, meta.cars)) {
-      return;
-    }
-    const carHeader = await this.loadCarHeaderFromMeta(meta);
-    carHeader.compact.map((c) => c.toString()).forEach(this.seenCompacted.add, this.seenCompacted);
-    await this.getMoreReaders(carHeader.cars.flat());
-    this.carLog = [...uniqueCids([meta.cars, ...this.carLog, ...carHeader.cars], this.seenCompacted)];
-    await this.ebOpts.applyMeta?.(carHeader.meta);
-  }
-  // protected async ingestKeyFromMeta(meta: DbMeta): Promise<void> {
-  //   const { key } = meta;
-  //   if (key) {
-  //     await this.setKey(key);
-  //   }
-  // }
-  async loadCarHeaderFromMeta({ cars: cids }) {
-    const reader = await this.loadCar(cids[0]);
-    return await parseCarFile(reader, this.logger);
-  }
-  // async _getKey(): Promise<string | undefined> {
-  //   if (this.key) return this.key;
-  //   // generate a random key
-  //   if (!this.ebOpts.public) {
-  //     await this.setKey(toHexString(this.ebOpts.crypto.randomBytes(32)));
-  //   }
-  //   return this.key || undefined;
-  // }
-  async commitFiles(t, done) {
-    await this.ready();
-    const fstore = await this.fileStore();
-    const wstore = await this.WALStore();
-    return this.commitQueue.enqueue(() => commitFiles(fstore, wstore, t, done));
   }
-  async loadFileCar(cid) {
-    return await this.storesLoadCar(cid, await this.fileStore(), this.remoteFileStore);
+  async delete(url) {
+    const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
+    for (const rfrag of rfrags) {
+      if (rfrag.isErr()) {
+        return import_cement3.Result.Err(rfrag.Err());
+      }
+      const frag = rfrag.Ok();
+      let fragUrl;
+      if (rfrags.length > 1) {
+        const fidStr = import_base583.base58btc.encode(frag.fid);
+        fragUrl = url.build().setParam("fid" /* FRAG_FID */, fidStr).setParam("len" /* FRAG_LEN */, frag.len.toString()).setParam("headerSize" /* FRAG_HEAD */, this.headerSize.toString()).URI();
+      } else {
+        fragUrl = url;
+      }
+      await this.innerGW.delete(fragUrl);
+    }
+    return import_cement3.Result.Ok(void 0);
   }
-  async commit(t, done, opts = { noLoader: false, compact: false }) {
-    await this.ready();
-    const fstore = await this.fileStore();
-    const params = {
-      encoder: (await fstore.keyedCrypto()).codec(),
-      carLog: this.carLog,
-      carStore: fstore,
-      WALStore: await this.WALStore(),
-      metaStore: await this.metaStore(),
-      threshold: this.ebOpts.threshold
-    };
-    return this.commitQueue.enqueue(async () => {
-      await this.cacheTransaction(t);
-      const ret = await commit(params, t, done, opts);
-      await this.updateCarLog(ret.cgrp, ret.header, !!opts.compact);
-      return ret.cgrp;
+};
+
+// src/blockstore/meta-key-helper.ts
+var import_dag_json = require("@ipld/dag-json");
+var import_clock = require("@web3-storage/pail/clock");
+var import_multiformats = require("multiformats");
+var import_base64 = require("multiformats/bases/base64");
+var import_cement7 = require("@adviser/cement");
+
+// src/runtime/key-bag.ts
+var key_bag_exports = {};
+__export(key_bag_exports, {
+  KeyBag: () => KeyBag,
+  defaultKeyBagOpts: () => defaultKeyBagOpts,
+  getKeyBag: () => getKeyBag,
+  registerKeyBagProviderFactory: () => registerKeyBagProviderFactory
+});
+var import_cement6 = require("@adviser/cement");
+init_utils();
+var import_base584 = require("multiformats/bases/base58");
+init_types();
+var KeyBag = class {
+  constructor(rt) {
+    this.rt = rt;
+    this._warnOnce = new import_cement6.ResolveOnce();
+    this._seq = new import_cement6.ResolveSeq();
+    this.logger = ensureLogger(rt.sthis, "KeyBag", {
+      id: rt.id()
     });
+    this.logger.Debug().Msg("KeyBag created");
   }
-  async updateCarLog(cids, fp, compact) {
-    if (compact) {
-      const previousCompactCid = fp.compact[fp.compact.length - 1];
-      fp.compact.map((c) => c.toString()).forEach(this.seenCompacted.add, this.seenCompacted);
-      this.carLog = [...uniqueCids([...this.carLog, ...fp.cars, cids], this.seenCompacted)];
-      await this.removeCidsForCompact(previousCompactCid[0]).catch((e) => e);
-    } else {
-      this.carLog.unshift(cids);
+  async subtleKey(key) {
+    const extractable = this.rt.url.getParam("extractKey") === "_deprecated_internal_api";
+    if (extractable) {
+      this._warnOnce.once(
+        () => this.logger.Warn().Msg("extractKey is enabled via _deprecated_internal_api --- handle keys safely!!!")
+      );
     }
+    return await this.rt.crypto.importKey(
+      "raw",
+      // raw or jwk
+      import_base584.base58btc.decode(key),
+      // hexStringToUint8Array(key), // raw data
+      "AES-GCM",
+      extractable,
+      ["encrypt", "decrypt"]
+    );
   }
-  async cacheTransaction(t) {
-    for await (const block of t.entries()) {
-      const sBlock = block.cid.toString();
-      if (!this.getBlockCache.has(sBlock)) {
-        this.getBlockCache.set(sBlock, block);
+  async ensureKeyFromUrl(url, keyFactory) {
+    const storeKey = url.getParam("storekey" /* STORE_KEY */);
+    if (storeKey === "insecure") {
+      return import_cement6.Result.Ok(url);
+    }
+    if (!storeKey) {
+      const keyName = `@${keyFactory()}@`;
+      const ret = await this.getNamedKey(keyName);
+      if (ret.isErr()) {
+        return ret;
       }
+      const urb = url.build().setParam("storekey" /* STORE_KEY */, keyName);
+      return import_cement6.Result.Ok(urb.URI());
     }
-  }
-  async cacheCarReader(carCidStr, reader) {
-    if (this.processedCars.has(carCidStr)) return;
-    this.processedCars.add(carCidStr);
-    for await (const block of reader.blocks()) {
-      const sBlock = block.cid.toString();
-      if (!this.getBlockCache.has(sBlock)) {
-        this.getBlockCache.set(sBlock, block);
+    if (storeKey.startsWith("@") && storeKey.endsWith("@")) {
+      const ret = await this.getNamedKey(storeKey);
+      if (ret.isErr()) {
+        return ret;
       }
     }
+    return import_cement6.Result.Ok(url);
   }
-  async removeCidsForCompact(cid) {
-    const carHeader = await this.loadCarHeaderFromMeta({
-      cars: [cid]
+  async toKeyWithFingerPrint(keyStr) {
+    const material = import_base584.base58btc.decode(keyStr);
+    const key = await this.subtleKey(keyStr);
+    const fpr = await this.rt.crypto.digestSHA256(material);
+    return import_cement6.Result.Ok({
+      key,
+      fingerPrint: import_base584.base58btc.encode(new Uint8Array(fpr))
     });
-    for (const cids of carHeader.compact) {
-      for (const cid2 of cids) {
-        await (await this.carStore()).remove(cid2);
-      }
-    }
   }
-  // async flushCars() {
-  //   await this.ready
-  //   // for each cid in car log, make a dbMeta
-  //   for (const cid of this.carLog) {
-  //     const dbMeta = { car: cid, key: this.key || null } as DbMeta
-  //     await this.remoteWAL!.enqueue(dbMeta, { public: false })
-  //   }
-  // }
-  async *entries(cache2 = true) {
-    await this.ready();
-    if (cache2) {
-      for (const [, block] of this.getBlockCache) {
-        yield block;
+  async setNamedKey(name, key) {
+    return this._seq.add(() => this._setNamedKey(name, key));
+  }
+  // avoid deadlock
+  async _setNamedKey(name, key) {
+    const item = {
+      name,
+      key
+    };
+    const bag = await this.rt.getBag();
+    this.logger.Debug().Str("name", name).Msg("setNamedKey");
+    await bag.set(name, item);
+    return await this.toKeyWithFingerPrint(item.key);
+  }
+  async getNamedExtractableKey(name, failIfNotFound = false) {
+    const ret = await this.getNamedKey(name, failIfNotFound);
+    if (ret.isErr()) {
+      return ret;
+    }
+    const named = ret.Ok();
+    return import_cement6.Result.Ok({
+      ...named,
+      extract: async () => {
+        const ext = new Uint8Array(await this.rt.crypto.exportKey("raw", named.key));
+        return {
+          key: ext,
+          keyStr: import_base584.base58btc.encode(ext)
+        };
       }
-    } else {
-      for (const [, block] of this.getBlockCache) {
-        yield block;
+    });
+  }
+  async getNamedKey(name, failIfNotFound = false) {
+    const id = this.rt.sthis.nextId(4).str;
+    return this._seq.add(async () => {
+      const bag = await this.rt.getBag();
+      const named = await bag.get(name);
+      if (named) {
+        const fpr = await this.toKeyWithFingerPrint(named.key);
+        this.logger.Debug().Str("id", id).Str("name", name).Result("fpr", fpr).Msg("fingerPrint getNamedKey");
+        return fpr;
       }
-      for (const cids of this.carLog) {
-        for (const cid of cids) {
-          const reader = await this.loadCar(cid);
-          if (!reader) throw this.logger.Error().Ref("cid", cid).Msg("missing car reader").AsError();
-          for await (const block of reader.blocks()) {
-            const sCid = block.cid.toString();
-            if (!this.getBlockCache.has(sCid)) {
-              yield block;
-            }
-          }
-        }
+      if (failIfNotFound) {
+        this.logger.Debug().Str("id", id).Str("name", name).Msg("failIfNotFound getNamedKey");
+        return import_cement6.Result.Err(new Error(`Key not found: ${name}`));
       }
-    }
+      const ret = await this._setNamedKey(name, import_base584.base58btc.encode(this.rt.crypto.randomBytes(this.rt.keyLength)));
+      this.logger.Debug().Str("id", id).Str("name", name).Result("fpr", ret).Msg("createKey getNamedKey-post");
+      return ret;
+    });
   }
-  async getBlock(cid) {
-    await this.ready();
-    const sCid = cid.toString();
-    if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
-    const getCarCid = async (carCid) => {
-      if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
-      const reader = await this.loadCar(carCid);
-      if (!reader) {
-        throw this.logger.Error().Ref("cid", carCid).Msg("missing car reader").AsError();
+};
+var keyBagProviderFactories = new Map(
+  [
+    {
+      protocol: "file:",
+      factory: async (url, sthis) => {
+        const { KeyBagProviderFile: KeyBagProviderFile2 } = await Promise.resolve().then(() => (init_key_bag_file(), key_bag_file_exports));
+        return new KeyBagProviderFile2(url, sthis);
       }
-      await this.cacheCarReader(carCid.toString(), reader).catch(() => {
-        return;
-      });
-      if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
-      throw this.logger.Error().Str("cid", sCid).Msg("block not in reader").AsError();
-    };
-    const getCompactCarCids = async (carCid) => {
-      const reader = await this.loadCar(carCid);
-      if (!reader) {
-        throw this.logger.Error().Str("cid", carCid.toString()).Msg("missing car reader").AsError();
+    },
+    {
+      protocol: "indexdb:",
+      factory: async (url, sthis) => {
+        const { KeyBagProviderIndexDB: KeyBagProviderIndexDB2 } = await Promise.resolve().then(() => (init_key_bag_indexdb(), key_bag_indexdb_exports));
+        return new KeyBagProviderIndexDB2(url, sthis);
       }
-      const header = await parseCarFile(reader, this.logger);
-      const compacts = header.compact;
-      let got2;
-      const batchSize2 = 5;
-      for (let i = 0; i < compacts.length; i += batchSize2) {
-        const promises = [];
-        for (let j = i; j < Math.min(i + batchSize2, compacts.length); j++) {
-          for (const cid2 of compacts[j]) {
-            promises.push(getCarCid(cid2));
-          }
-        }
-        try {
-          got2 = await Promise.any(promises);
-        } catch {
-        }
-        if (got2) break;
-      }
-      if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
-      throw this.logger.Error().Str("cid", sCid).Msg("block not in compact reader").AsError();
-    };
-    let got;
-    const batchSize = 5;
-    for (let i = 0; i < this.carLog.length; i += batchSize) {
-      const batch = this.carLog.slice(i, i + batchSize);
-      const promises = batch.flatMap((slice) => slice.map(getCarCid));
-      try {
-        got = await Promise.any(promises);
-      } catch {
-      }
-      if (got) break;
     }
-    if (!got) {
-      try {
-        got = await getCompactCarCids(this.carLog[this.carLog.length - 1][0]);
-      } catch {
+  ].map((i) => [i.protocol, i])
+);
+function registerKeyBagProviderFactory(item) {
+  const protocol = item.protocol.endsWith(":") ? item.protocol : item.protocol + ":";
+  keyBagProviderFactories.set(protocol, {
+    ...item,
+    protocol
+  });
+}
+function defaultKeyBagOpts(sthis, kbo) {
+  kbo = kbo || {};
+  if (kbo.keyRuntime) {
+    return kbo.keyRuntime;
+  }
+  const logger = ensureLogger(sthis, "KeyBag");
+  let url;
+  if (kbo.url) {
+    url = import_cement6.URI.from(kbo.url);
+    logger.Debug().Url(url).Msg("from opts");
+  } else {
+    let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
+    if ((0, import_cement6.runtimeFn)().isBrowser) {
+      url = import_cement6.URI.from(bagFnameOrUrl || "indexdb://fp-keybag");
+    } else {
+      if (!bagFnameOrUrl) {
+        const home = sthis.env.get("HOME");
+        bagFnameOrUrl = `${home}/.fireproof/keybag`;
+        url = import_cement6.URI.from(`file://${bagFnameOrUrl}`);
+      } else {
+        url = import_cement6.URI.from(bagFnameOrUrl);
       }
     }
-    return got;
+    logger.Debug().Url(url).Msg("from env");
   }
-  async loadCar(cid) {
-    if (!this.carStore) {
-      throw this.logger.Error().Msg("car store not initialized").AsError();
+  let keyProviderFactory;
+  switch (url.protocol) {
+    case "file:":
+      keyProviderFactory = async () => {
+        const { KeyBagProviderFile: KeyBagProviderFile2 } = await Promise.resolve().then(() => (init_key_bag_file(), key_bag_file_exports));
+        return new KeyBagProviderFile2(url, sthis);
+      };
+      break;
+    case "indexdb:":
+      keyProviderFactory = async () => {
+        const { KeyBagProviderIndexDB: KeyBagProviderIndexDB2 } = await Promise.resolve().then(() => (init_key_bag_indexdb(), key_bag_indexdb_exports));
+        return new KeyBagProviderIndexDB2(url, sthis);
+      };
+      break;
+    case "memory:":
+      keyProviderFactory = async () => {
+        const { KeyBagProviderMemory: KeyBagProviderMemory2 } = await Promise.resolve().then(() => (init_key_bag_memory(), key_bag_memory_exports));
+        return new KeyBagProviderMemory2(url, sthis);
+      };
+      break;
+    default:
+      throw logger.Error().Url(url).Msg("unsupported protocol").AsError();
+  }
+  if (url.hasParam("masterkey")) {
+    throw logger.Error().Url(url).Msg("masterkey is not supported").AsError();
+  }
+  return {
+    url,
+    crypto: kbo.crypto || (0, import_cement6.toCryptoRuntime)({}),
+    sthis,
+    logger,
+    keyLength: kbo.keyLength || 16,
+    getBag: keyProviderFactory,
+    id: () => {
+      return url.toString();
     }
-    const loaded = await this.storesLoadCar(cid, await this.carStore(), this.remoteCarStore);
-    return loaded;
+  };
+}
+var _keyBags = new import_cement6.KeyedResolvOnce();
+async function getKeyBag(sthis, kbo = {}) {
+  await sthis.start();
+  const rt = defaultKeyBagOpts(sthis, kbo);
+  return _keyBags.get(rt.id()).once(async () => new KeyBag(rt));
+}
+
+// src/blockstore/meta-key-helper.ts
+async function decodeGatewayMetaBytesToDbMeta(sthis, byteHeads) {
+  const crdtEntries = JSON.parse(sthis.txt.decode(byteHeads));
+  if (!crdtEntries.length) {
+    sthis.logger.Debug().Str("byteHeads", new TextDecoder().decode(byteHeads)).Msg("No CRDT entries found");
+    return [];
   }
-  async makeDecoderAndCarReader(cid, local, remote) {
-    const cidsString = cid.toString();
-    let loadedCar = void 0;
-    let activeStore = local;
-    try {
-      this.logger.Debug().Str("cid", cidsString).Msg("loading car");
-      loadedCar = await local.load(cid);
-      this.logger.Debug().Bool("loadedCar", loadedCar).Msg("loaded");
-    } catch (e) {
-      if (remote) {
-        const remoteCar = await remote.load(cid);
-        if (remoteCar) {
-          this.logger.Debug().Ref("cid", remoteCar.cid).Msg("saving remote car locally");
-          await local.save(remoteCar);
-          loadedCar = remoteCar;
-          activeStore = remote;
+  if (!crdtEntries.map) {
+    sthis.logger.Debug().Str("crdtEntries", JSON.stringify(crdtEntries)).Msg("No data in CRDT entries");
+    return [];
+  }
+  return Promise.all(
+    crdtEntries.map(async (crdtEntry) => {
+      const eventBlock = await (0, import_clock.decodeEventBlock)(import_base64.base64pad.decode(crdtEntry.data));
+      const dbMeta = (0, import_dag_json.parse)(sthis.txt.decode(eventBlock.value.data.dbMeta));
+      return {
+        eventCid: eventBlock.cid,
+        parents: crdtEntry.parents,
+        dbMeta
+      };
+    })
+  );
+}
+async function setCryptoKeyFromGatewayMetaPayload(uri, sthis, data) {
+  try {
+    sthis.logger.Debug().Str("uri", uri.toString()).Msg("Setting crypto key from gateway meta payload");
+    const keyInfo = await decodeGatewayMetaBytesToDbMeta(sthis, data);
+    if (keyInfo.length) {
+      const dbMeta = keyInfo[0].dbMeta;
+      if (dbMeta.key) {
+        const kb = await getKeyBag(sthis);
+        const keyName = getStoreKeyName(uri);
+        const res = await kb.setNamedKey(keyName, dbMeta.key);
+        if (res.isErr()) {
+          sthis.logger.Debug().Str("keyName", keyName).Str("dbMeta.key", dbMeta.key).Msg("Failed to set named key");
+          throw res.Err();
         }
-      } else {
-        this.logger.Error().Str("cid", cidsString).Err(e).Msg("loading car");
       }
+      sthis.logger.Debug().Str("dbMeta.key", dbMeta.key).Str("uri", uri.toString()).Msg("Set crypto key from gateway meta payload");
+      return import_cement7.Result.Ok(dbMeta);
     }
-    if (!loadedCar) {
-      throw this.logger.Error().Url(local.url()).Str("cid", cidsString).Msg("missing car files").AsError();
-    }
-    const bytes = await decode({ bytes: loadedCar.bytes, hasher: import_sha23.sha256, codec: (await activeStore.keyedCrypto()).codec() });
-    const rawReader = await import_car.CarReader.fromBytes(bytes.value);
-    const readerP = Promise.resolve(rawReader);
-    const cachedReaderP = readerP.then(async (reader) => {
-      await this.cacheCarReader(cidsString, reader).catch((e) => {
-        this.logger.Error().Err(e).Str("cid", cidsString).Msg("error caching car reader");
-        return;
-      });
-      return reader;
-    });
-    this.carReaders.set(cidsString, cachedReaderP);
-    return readerP;
+    sthis.logger.Debug().Str("data", new TextDecoder().decode(data)).Msg("No crypto in gateway meta payload");
+    return import_cement7.Result.Ok(void 0);
+  } catch (error) {
+    sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
+    return import_cement7.Result.Err(error);
   }
-  //What if instead it returns an Array of CarHeader
-  async storesLoadCar(cid, local, remote) {
-    const cidsString = cid.toString();
-    let dacr = this.carReaders.get(cidsString);
-    if (!dacr) {
-      dacr = this.makeDecoderAndCarReader(cid, local, remote);
-      this.carReaders.set(cidsString, dacr);
+}
+async function addCryptoKeyToGatewayMetaPayload(uri, sthis, body) {
+  try {
+    sthis.logger.Debug().Str("uri", uri.toString()).Msg("Adding crypto key to gateway meta payload");
+    const keyName = getStoreKeyName(uri);
+    const kb = await getKeyBag(sthis);
+    const res = await kb.getNamedExtractableKey(keyName, true);
+    if (res.isErr()) {
+      sthis.logger.Error().Str("keyName", keyName).Msg("Failed to get named extractable key");
+      throw res.Err();
     }
-    return dacr;
+    const keyData = await res.Ok().extract();
+    const dbMetas = await decodeGatewayMetaBytesToDbMeta(sthis, body);
+    const { dbMeta, parents } = dbMetas[0];
+    const parentLinks = parents.map((p) => import_multiformats.CID.parse(p));
+    dbMeta.key = keyData.keyStr;
+    const events = await Promise.all([dbMeta].map((dbMeta2) => createDbMetaEventBlock(sthis, dbMeta2, parentLinks)));
+    const encoded = await encodeEventsWithParents(sthis, events, parentLinks);
+    sthis.logger.Debug().Str("uri", uri.toString()).Msg("Added crypto key to gateway meta payload");
+    return import_cement7.Result.Ok(encoded);
+  } catch (error) {
+    sthis.logger.Error().Err(error).Msg("Failed to add crypto key to gateway meta payload");
+    return import_cement7.Result.Err(error);
   }
-  async getMoreReaders(cids) {
-    const limit = (0, import_p_limit.default)(5);
-    const missing = cids.filter((cid) => !this.carReaders.has(cid.toString()));
-    await Promise.all(missing.map((cid) => limit(() => this.loadCar(cid))));
+}
+function getStoreKeyName(url) {
+  const storeKeyName = [url.getParam("localName") || url.getParam("name")];
+  const idx = url.getParam("index");
+  if (idx) {
+    storeKeyName.push(idx);
   }
-};
+  storeKeyName.push("data");
+  return `@${storeKeyName.join(":")}@`;
+}
+async function createDbMetaEventBlock(sthis, dbMeta, parents) {
+  const event = await import_clock.EventBlock.create(
+    {
+      dbMeta: sthis.txt.encode((0, import_dag_json.format)(dbMeta))
+    },
+    parents
+  );
+  return event;
+}
+async function encodeEventsWithParents(sthis, events, parents) {
+  const crdtEntries = events.map((event) => {
+    const base64String = import_base64.base64pad.encode(event.bytes);
+    return {
+      cid: event.cid.toString(),
+      data: base64String,
+      parents: parents.map((p) => p.toString())
+    };
+  });
+  return sthis.txt.encode(JSON.stringify(crdtEntries));
+}
 
-// src/runtime/keyed-crypto.ts
-var keyed_crypto_exports = {};
-__export(keyed_crypto_exports, {
-  BlockIvKeyIdCodec: () => BlockIvKeyIdCodec,
-  keyedCryptoFactory: () => keyedCryptoFactory
+// src/blockstore/store.ts
+var import_p_retry = __toESM(require("p-retry"), 1);
+var import_p_map = __toESM(require("p-map"), 1);
+
+// src/blockstore/loader.ts
+var import_p_limit = __toESM(require("p-limit"), 1);
+var import_car = require("@ipld/car");
+var import_cement9 = require("@adviser/cement");
+
+// src/runtime/wait-pr-multiformats/block.ts
+var block_exports = {};
+__export(block_exports, {
+  Block: () => Block,
+  create: () => create,
+  createUnsafe: () => createUnsafe,
+  decode: () => decode3,
+  encode: () => encode3
 });
+var import_multiformats2 = require("multiformats");
+var import_block = require("multiformats/block");
+var Block = import_block.Block;
+async function decode3({
+  bytes,
+  codec: codec3,
+  hasher: hasher7
+}) {
+  if (bytes == null) throw new Error('Missing required argument "bytes"');
+  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
+  const value = await Promise.resolve(codec3.decode(bytes));
+  const hash = await hasher7.digest(bytes);
+  const cid = import_multiformats2.CID.create(1, codec3.code, hash);
+  return new import_block.Block({ value, bytes, cid });
+}
+async function encode3({
+  value,
+  codec: codec3,
+  hasher: hasher7
+}) {
+  if (typeof value === "undefined") throw new Error('Missing required argument "value"');
+  if (codec3 == null || hasher7 == null) throw new Error("Missing required argument: codec or hasher");
+  const bytes = await Promise.resolve(codec3.encode(value));
+  const hash = await hasher7.digest(bytes);
+  const cid = import_multiformats2.CID.create(1, codec3.code, hash);
+  return new import_block.Block({ value, bytes, cid });
+}
+async function create({
+  bytes,
+  cid,
+  hasher: hasher7,
+  codec: codec3
+}) {
+  if (bytes == null) throw new Error('Missing required argument "bytes"');
+  if (hasher7 == null) throw new Error('Missing required argument "hasher"');
+  const value = await Promise.resolve(codec3.decode(bytes));
+  const hash = await hasher7.digest(bytes);
+  if (!import_multiformats2.bytes.equals(cid.multihash.bytes, hash.bytes)) {
+    throw new Error("CID hash does not match bytes");
+  }
+  return createUnsafe({
+    bytes,
+    cid,
+    value,
+    codec: codec3
+  });
+}
+async function createUnsafe({
+  bytes,
+  cid,
+  value: maybeValue,
+  codec: codec3
+}) {
+  const value = await Promise.resolve(maybeValue !== void 0 ? maybeValue : codec3?.decode(bytes));
+  if (value === void 0) throw new Error('Missing required argument, must either provide "value" or "codec"');
+  return new Block({
+    cid,
+    bytes,
+    value
+  });
+}
+
+// src/blockstore/loader-helpers.ts
+var import_sha22 = require("multiformats/hashes/sha2");
+var dagCodec = __toESM(require("@ipld/dag-cbor"), 1);
+async function parseCarFile(reader, logger) {
+  const roots = await reader.getRoots();
+  const header = await reader.get(roots[0]);
+  if (!header) throw logger.Error().Msg("missing header block").AsError();
+  const dec = await decode3({ bytes: header.bytes, hasher: import_sha22.sha256, codec: dagCodec });
+  const fpvalue = dec.value;
+  if (fpvalue && !fpvalue.fp) {
+    throw logger.Error().Msg("missing fp").AsError();
+  }
+  return fpvalue.fp;
+}
+
+// src/blockstore/transaction.ts
+var import_block3 = require("@web3-storage/pail/block");
+init_types();
+var import_cement8 = require("@adviser/cement");
 init_utils();
-var import_base583 = require("multiformats/bases/base58");
-var import_sha24 = require("multiformats/hashes/sha2");
-var CBOR = __toESM(require("cborg"), 1);
-var generateIV = {
-  random: {
+var CarTransaction = class extends import_block3.MemoryBlockstore {
+  constructor(parent, opts = { add: true, noLoader: false }) {
+    super();
+    if (opts.add) {
+      parent.transactions.add(this);
+    }
+    this.parent = parent;
+  }
+  async get(cid) {
+    return await this.superGet(cid) || falsyToUndef(await this.parent.get(cid));
+  }
+  async superGet(cid) {
+    return super.get(cid);
+  }
+};
+function defaultedBlockstoreRuntime(sthis, opts, component, ctx) {
+  const logger = ensureLogger(sthis, component, ctx);
+  return {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    calc: async (ko, crypto, data) => {
-      return crypto.randomBytes(ko.ivLength);
+    applyMeta: (meta, snap) => {
+      return Promise.resolve();
     },
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    verify: async (ko, crypto, iv, data) => {
-      return true;
+    compact: async (blocks) => {
+      return {};
+    },
+    autoCompact: 100,
+    public: false,
+    // name: undefined,
+    threshold: 1e3 * 1e3,
+    ...opts,
+    logger,
+    keyBag: opts.keyBag || {},
+    crypto: (0, import_cement8.toCryptoRuntime)(opts.crypto),
+    storeUrls: opts.storeUrls,
+    // storeEnDeFile: ensureStoreEnDeFile(opts.storeEnDeFile),
+    // store,
+    storeRuntime: toStoreRuntime(sthis, ensureStoreEnDeFile(opts.storeEnDeFile))
+  };
+}
+function blockstoreFactory(sthis, opts) {
+  return new EncryptedBlockstore(sthis, opts);
+}
+var BaseBlockstore = class {
+  constructor(ebOpts) {
+    this.transactions = /* @__PURE__ */ new Set();
+    this.sthis = ensureSuperThis(ebOpts);
+    this.ebOpts = defaultedBlockstoreRuntime(this.sthis, ebOpts, "BaseBlockstore");
+    this.sthis = ensureSuperThis(ebOpts);
+    this.ebOpts = defaultedBlockstoreRuntime(this.sthis, ebOpts, "BaseBlockstore");
+    this.logger = this.ebOpts.logger;
+  }
+  // readonly name?: string;
+  // ready: Promise<void>;
+  ready() {
+    return Promise.resolve();
+  }
+  async close() {
+  }
+  async destroy() {
+  }
+  async compact() {
+  }
+  async get(cid) {
+    if (!cid) throw this.logger.Error().Msg("required cid").AsError();
+    for (const f of this.transactions) {
+      const v = await f.superGet(cid);
+      if (v) return v;
     }
-  },
-  hash: {
-    calc: async (ko, crypto, data) => {
-      const hash = await import_sha24.sha256.digest(data);
-      const hashBytes = new Uint8Array(hash.bytes);
-      const hashArray = new Uint8Array(ko.ivLength);
-      for (let i = 0; i < hashBytes.length; i++) {
-        hashArray[i % ko.ivLength] ^= hashBytes[i];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async put(cid, block) {
+    throw this.logger.Error().Msg("use a transaction to put").AsError();
+  }
+  // TransactionMeta
+  async transaction(fn, _opts) {
+    this.logger.Debug().Msg("enter transaction");
+    const t = new CarTransaction(this, _opts);
+    this.logger.Debug().Msg("post CarTransaction");
+    const done = await fn(t);
+    this.logger.Debug().Msg("post fn");
+    this.lastTxMeta = done;
+    return { t, meta: done };
+  }
+  openTransaction(opts = { add: true, noLoader: false }) {
+    return new CarTransaction(this, opts);
+  }
+  async commitTransaction(t, done, opts) {
+    if (!this.loader) throw this.logger.Error().Msg("loader required to commit").AsError();
+    const cars = await this.loader?.commit(t, done, opts);
+    if (this.ebOpts.autoCompact && this.loader.carLog.length > this.ebOpts.autoCompact) {
+      setTimeout(() => void this.compact(), 10);
+    }
+    if (cars) {
+      this.transactions.delete(t);
+      return { meta: done, cars, t };
+    }
+    throw this.logger.Error().Msg("failed to commit car files").AsError();
+  }
+  async *entries() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of this.transactions) {
+      for await (const blk of t.entries()) {
+        if (seen.has(blk.cid.toString())) continue;
+        seen.add(blk.cid.toString());
+        yield blk;
       }
-      return hashArray;
-    },
-    verify: async function(ko, crypto, iv, data) {
-      return ko.url.getParam("ivverify") !== "disable" && UInt8ArrayEqual(iv, await this.calc(ko, crypto, data));
     }
   }
 };
-function getGenerateIVFn(url, opts) {
-  const ivhash = opts.ivCalc || url.getParam("ivhash") || "hash";
-  return generateIV[ivhash] || generateIV["hash"];
-}
-var BlockIvKeyIdCodec = class {
-  constructor(ko, iv, opts) {
-    this.code = 3147065;
-    this.name = "Fireproof@encrypted-block:aes-gcm";
-    this.ko = ko;
-    this.iv = iv;
-    this.opts = opts || {};
+var EncryptedBlockstore = class extends BaseBlockstore {
+  constructor(sthis, ebOpts) {
+    super(ebOpts);
+    this.compacting = false;
+    this.logger = ensureLogger(this.sthis, "EncryptedBlockstore", {
+      this: 1
+    });
+    this.loader = new Loader(sthis, ebOpts);
   }
-  async encode(data) {
-    const calcIv = this.iv || await getGenerateIVFn(this.ko.url, this.opts).calc(this.ko, this.ko.crypto, data);
-    const { iv } = this.ko.algo(calcIv);
-    const fprt = await this.ko.fingerPrint();
-    const keyId = import_base583.base58btc.decode(fprt);
-    this.ko.logger.Debug().Str("fp", fprt).Msg("encode");
-    return CBOR.encode({
-      iv,
-      keyId,
-      data: await this.ko._encrypt({ iv, bytes: data })
+  ready() {
+    return this.loader.ready();
+  }
+  close() {
+    return this.loader.close();
+  }
+  destroy() {
+    return this.loader.destroy();
+  }
+  async get(cid) {
+    const got = await super.get(cid);
+    if (got) return got;
+    if (!this.loader) {
+      return;
+    }
+    return falsyToUndef(await this.loader.getBlock(cid));
+  }
+  async transaction(fn, opts = { noLoader: false }) {
+    this.logger.Debug().Msg("enter transaction");
+    const { t, meta: done } = await super.transaction(fn);
+    this.logger.Debug().Msg("post super.transaction");
+    const cars = await this.loader.commit(t, done, opts);
+    this.logger.Debug().Msg("post this.loader.commit");
+    if (this.ebOpts.autoCompact && this.loader.carLog.length > this.ebOpts.autoCompact) {
+      setTimeout(() => void this.compact(), 10);
+    }
+    if (cars) {
+      this.transactions.delete(t);
+      return { meta: done, cars, t };
+    }
+    throw this.logger.Error().Msg("failed to commit car files").AsError();
+  }
+  async getFile(car, cid) {
+    await this.ready();
+    if (!this.loader) throw this.logger.Error().Msg("loader required to get file, database must be named").AsError();
+    const reader = await this.loader.loadFileCar(
+      car
+      /*, isPublic */
+    );
+    const block = await reader.get(cid);
+    if (!block) throw this.logger.Error().Str("cid", cid.toString()).Msg(`Missing block`).AsError();
+    return block.bytes;
+  }
+  async compact() {
+    await this.ready();
+    if (!this.loader) throw this.logger.Error().Msg("loader required to compact").AsError();
+    if (this.loader.carLog.length < 2) return;
+    const compactFn = this.ebOpts.compact || ((blocks) => this.defaultCompact(blocks, this.logger));
+    if (!compactFn || this.compacting) return;
+    const blockLog = new CompactionFetcher(this);
+    this.compacting = true;
+    const meta = await compactFn(blockLog);
+    await this.loader?.commit(blockLog.loggedBlocks, meta, {
+      compact: true,
+      noLoader: true
     });
+    this.compacting = false;
   }
-  async decode(abytes) {
-    let bytes;
-    if (abytes instanceof Uint8Array) {
-      bytes = abytes;
-    } else {
-      bytes = new Uint8Array(abytes);
+  async defaultCompact(blocks, logger) {
+    if (!this.loader) {
+      throw logger.Error().Msg("no loader").AsError();
     }
-    const { iv, keyId, data } = CBOR.decode(bytes);
-    const fprt = await this.ko.fingerPrint();
-    this.ko.logger.Debug().Str("fp", import_base583.base58btc.encode(keyId)).Msg("decode");
-    if (import_base583.base58btc.encode(keyId) !== fprt) {
-      throw this.ko.logger.Error().Str("fp", fprt).Str("keyId", import_base583.base58btc.encode(keyId)).Msg("keyId mismatch").AsError();
+    if (!this.lastTxMeta) {
+      throw logger.Error().Msg("no lastTxMeta").AsError();
     }
-    const result = await this.ko._decrypt({ iv, bytes: data });
-    if (!this.opts?.noIVVerify && !await getGenerateIVFn(this.ko.url, this.opts).verify(this.ko, this.ko.crypto, iv, result)) {
-      throw this.ko.logger.Error().Msg("iv missmatch").AsError();
+    for await (const blk of this.loader.entries(false)) {
+      blocks.loggedBlocks.putSync(blk.cid, blk.bytes);
+    }
+    for (const t of this.transactions) {
+      for await (const blk of t.entries()) {
+        blocks.loggedBlocks.putSync(blk.cid, blk.bytes);
+      }
+    }
+    return this.lastTxMeta;
+  }
+  async *entries() {
+    for await (const blk of this.loader.entries()) {
+      yield blk;
     }
-    return result;
   }
 };
-var keyedCrypto = class {
-  constructor(url, key, cyopt, sthis) {
-    this.ivLength = 12;
-    this.isEncrypting = true;
-    this.logger = ensureLogger(sthis, "keyedCrypto");
-    this.crypto = cyopt;
-    this.key = key;
-    this.url = url;
+var CompactionFetcher = class {
+  constructor(blocks) {
+    this.blockstore = blocks;
+    this.loggedBlocks = new CarTransaction(blocks);
   }
-  fingerPrint() {
-    return Promise.resolve(this.key.fingerPrint);
+  async get(cid) {
+    const block = await this.blockstore.get(cid);
+    if (block) this.loggedBlocks.putSync(cid, block.bytes);
+    return falsyToUndef(block);
   }
-  codec(iv, opts) {
-    return new BlockIvKeyIdCodec(this, iv, opts);
+};
+
+// src/blockstore/commitor.ts
+var CBW = __toESM(require("@ipld/car/buffer-writer"), 1);
+var import_sha23 = require("multiformats/hashes/sha2");
+var dagCodec2 = __toESM(require("@ipld/dag-cbor"), 1);
+async function encodeCarFile(roots, t, codec3) {
+  let size = 0;
+  const headerSize = CBW.headerLength({ roots });
+  size += headerSize;
+  for (const { cid, bytes } of t.entries()) {
+    size += CBW.blockLength({ cid, bytes });
   }
-  algo(iv) {
-    return {
-      name: "AES-GCM",
-      iv: iv || this.crypto.randomBytes(this.ivLength),
-      tagLength: 128
-    };
+  const buffer = new Uint8Array(size);
+  const writer = CBW.createWriter(buffer, { headerSize });
+  for (const r of roots) {
+    writer.addRoot(r);
   }
-  async _decrypt(data) {
-    this.logger.Debug().Len(data.bytes, "bytes").Len(data.iv, "iv").Str("fp", this.key.fingerPrint).Msg("decrypting");
-    return new Uint8Array(await this.crypto.decrypt(this.algo(data.iv), this.key.key, data.bytes));
+  for (const { cid, bytes } of t.entries()) {
+    writer.write({ cid, bytes });
   }
-  async _encrypt(data) {
-    this.logger.Debug().Len(data.bytes).Str("fp", this.key.fingerPrint).Msg("encrypting");
-    const a = this.algo(data.iv);
-    return new Uint8Array(await this.crypto.encrypt(a, this.key.key, data.bytes));
+  writer.close();
+  return await encode3({ value: writer.bytes, hasher: import_sha23.sha256, codec: codec3 });
+}
+async function createCarFile(encoder, cid, t) {
+  return encodeCarFile([cid], t, encoder);
+}
+async function commitFiles(fileStore, walStore, t, done) {
+  const { files: roots } = makeFileCarHeader(done);
+  const cids = [];
+  const codec3 = (await fileStore.keyedCrypto()).codec();
+  const cars = await prepareCarFilesFiles(codec3, roots, t);
+  for (const car of cars) {
+    const { cid, bytes } = car;
+    await fileStore.save({ cid, bytes });
+    await walStore.enqueueFile(
+      cid
+      /*, !!opts.public*/
+    );
+    cids.push(cid);
   }
-};
-var nullCodec = class {
-  constructor() {
-    this.code = 0;
-    this.name = "Fireproof@unencrypted-block";
+  return cids;
+}
+function makeFileCarHeader(result) {
+  const files = [];
+  for (const [, meta] of Object.entries(result.files || {})) {
+    if (meta && typeof meta === "object" && "cid" in meta && meta !== null) {
+      files.push(meta.cid);
+    }
   }
-  encode(data) {
-    return data;
+  return { ...result, files };
+}
+async function prepareCarFilesFiles(encoder, roots, t) {
+  return [await encodeCarFile(roots, t, encoder)];
+}
+function makeCarHeader(meta, cars, compact = false) {
+  const coreHeader = compact ? { cars: [], compact: cars } : { cars, compact: [] };
+  return { ...coreHeader, meta };
+}
+async function encodeCarHeader(fp) {
+  return await encode3({
+    value: { fp },
+    hasher: import_sha23.sha256,
+    codec: dagCodec2
+  });
+}
+async function commit(params, t, done, opts = { noLoader: false, compact: false }) {
+  const fp = makeCarHeader(done, params.carLog, !!opts.compact);
+  const rootBlock = await encodeCarHeader(fp);
+  const cars = await prepareCarFiles(params.encoder, params.threshold, rootBlock, t);
+  const cids = [];
+  for (const car of cars) {
+    const { cid, bytes } = car;
+    await params.carStore.save({ cid, bytes });
+    cids.push(cid);
   }
-  decode(data) {
-    return data;
+  const newDbMeta = { cars: cids };
+  await params.WALStore.enqueue(newDbMeta, opts);
+  await params.metaStore.save(newDbMeta);
+  return { cgrp: cids, header: fp };
+}
+async function prepareCarFiles(encoder, threshold, rootBlock, t) {
+  const carFiles = [];
+  threshold = threshold || 128e3 * 8;
+  let clonedt = new CarTransaction(t.parent, { add: false, noLoader: false });
+  clonedt.putSync(rootBlock.cid, rootBlock.bytes);
+  let newsize = CBW.blockLength(toCIDBlock(rootBlock));
+  let cidRootBlock = rootBlock;
+  for (const { cid, bytes } of t.entries()) {
+    newsize += CBW.blockLength(toCIDBlock({ cid, bytes }));
+    if (newsize >= threshold) {
+      carFiles.push(await createCarFile(encoder, cidRootBlock.cid, clonedt));
+      clonedt = new CarTransaction(t.parent, { add: false, noLoader: false });
+      clonedt.putSync(cid, bytes);
+      cidRootBlock = { cid, bytes };
+      newsize = CBW.blockLength(toCIDBlock({ cid, bytes }));
+    } else {
+      clonedt.putSync(cid, bytes);
+    }
+  }
+  carFiles.push(await createCarFile(encoder, cidRootBlock.cid, clonedt));
+  return carFiles;
+}
+
+// src/blockstore/loader.ts
+var import_sha24 = require("multiformats/hashes/sha2");
+
+// src/blockstore/task-manager.ts
+init_utils();
+var TaskManager = class {
+  constructor(sthis, callback) {
+    this.eventsWeHandled = /* @__PURE__ */ new Set();
+    this.queue = [];
+    this.isProcessing = false;
+    this.logger = ensureLogger(sthis, "TaskManager");
+    this.callback = callback;
+  }
+  async handleEvent(cid, parents, dbMeta) {
+    for (const parent of parents) {
+      this.eventsWeHandled.add(parent.toString());
+    }
+    this.queue.push({ cid: cid.toString(), dbMeta, retries: 0 });
+    this.queue = this.queue.filter(({ cid: cid2 }) => !this.eventsWeHandled.has(cid2));
+    void this.processQueue();
+  }
+  async processQueue() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    const filteredQueue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
+    const first = filteredQueue[0];
+    if (!first) {
+      return;
+    }
+    try {
+      await this.callback(first.dbMeta);
+      this.eventsWeHandled.add(first.cid);
+      this.queue = this.queue.filter(({ cid }) => !this.eventsWeHandled.has(cid));
+    } catch (err) {
+      if (first.retries++ > 3) {
+        this.logger.Error().Str("cid", first.cid).Msg("failed to process event block after 3 retries");
+        this.queue = this.queue.filter(({ cid }) => cid !== first.cid);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      throw this.logger.Error().Err(err).Msg("failed to process event block").AsError();
+    } finally {
+      this.isProcessing = false;
+      if (this.queue.length > 0) {
+        void this.processQueue();
+      }
+    }
   }
 };
-var noCrypto = class {
-  constructor(url, cyrt, sthis) {
-    this.ivLength = 0;
-    this.code = 0;
-    this.name = "Fireproof@unencrypted-block";
-    this.isEncrypting = false;
-    this._fingerPrint = "noCrypto:" + Math.random();
-    this.logger = ensureLogger(sthis, "noCrypto");
-    this.crypto = cyrt;
-    this.url = url;
+
+// src/blockstore/loader.ts
+function carLogIncludesGroup(list, cids) {
+  return list.some((arr) => {
+    return arr.toString() === cids.toString();
+  });
+}
+function uniqueCids(list, remove = /* @__PURE__ */ new Set()) {
+  const byString = /* @__PURE__ */ new Map();
+  for (const cid of list) {
+    if (remove.has(cid.toString())) continue;
+    byString.set(cid.toString(), cid);
+  }
+  return [...byString.values()];
+}
+var Loader = class {
+  constructor(sthis, ebOpts) {
+    this.commitQueue = new CommitQueue();
+    this.isCompacting = false;
+    this.carReaders = /* @__PURE__ */ new Map();
+    this.seenCompacted = /* @__PURE__ */ new Set();
+    this.processedCars = /* @__PURE__ */ new Set();
+    this.carLog = [];
+    this.getBlockCache = /* @__PURE__ */ new Map();
+    this.seenMeta = /* @__PURE__ */ new Set();
+    this.writeLimit = (0, import_p_limit.default)(1);
+    this._carStore = new import_cement9.ResolveOnce();
+    this._fileStore = new import_cement9.ResolveOnce();
+    this._WALStore = new import_cement9.ResolveOnce();
+    this._metaStore = new import_cement9.ResolveOnce();
+    this.onceReady = new import_cement9.ResolveOnce();
+    this.sthis = sthis;
+    this.ebOpts = defaultedBlockstoreRuntime(
+      sthis,
+      {
+        ...ebOpts
+        // name,
+      },
+      "Loader"
+    );
+    this.logger = this.ebOpts.logger;
+    this.taskManager = new TaskManager(sthis, async (dbMeta) => {
+      await this.handleDbMetasFromStore([dbMeta]);
+    });
   }
-  fingerPrint() {
-    return Promise.resolve(this._fingerPrint);
+  async carStore() {
+    return this._carStore.once(
+      async () => this.ebOpts.storeRuntime.makeDataStore({
+        sthis: this.sthis,
+        url: this.ebOpts.storeUrls.data,
+        keybag: await this.keyBag()
+      })
+    );
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  codec(iv) {
-    return new nullCodec();
+  async fileStore() {
+    return this._fileStore.once(
+      async () => this.ebOpts.storeRuntime.makeDataStore({
+        sthis: this.sthis,
+        url: this.ebOpts.storeUrls.file,
+        keybag: await this.keyBag()
+      })
+    );
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  algo(iv) {
-    return {
-      name: "noCrypto",
-      iv: new Uint8Array(),
-      tagLength: 0
-    };
+  async WALStore() {
+    return this._WALStore.once(
+      async () => this.ebOpts.storeRuntime.makeWALStore({
+        sthis: this.sthis,
+        url: this.ebOpts.storeUrls.wal,
+        keybag: await this.keyBag()
+      })
+    );
   }
-  _decrypt() {
-    throw this.logger.Error().Msg("noCrypto.decrypt not implemented").AsError();
+  async metaStore() {
+    return this._metaStore.once(
+      async () => this.ebOpts.storeRuntime.makeMetaStore({
+        sthis: this.sthis,
+        url: this.ebOpts.storeUrls.meta,
+        keybag: await this.keyBag()
+      })
+    );
   }
-  _encrypt() {
-    throw this.logger.Error().Msg("noCrypto.decrypt not implemented").AsError();
+  keyBag() {
+    return getKeyBag(this.sthis, this.ebOpts.keyBag);
   }
-};
-async function keyedCryptoFactory(url, kb, sthis) {
-  const storekey = url.getParam("storekey");
-  if (storekey && storekey !== "insecure") {
-    let rkey = await kb.getNamedKey(storekey, true);
-    if (rkey.isErr()) {
-      try {
-        rkey = await kb.toKeyWithFingerPrint(storekey);
-      } catch (e) {
-        throw sthis.logger.Error().Err(e).Str("keybag", kb.rt.id()).Str("name", storekey).Msg("getNamedKey failed").AsError();
+  async ready() {
+    return this.onceReady.once(async () => {
+      const metas = await (await this.metaStore()).load();
+      if (this.ebOpts.meta) {
+        await this.handleDbMetasFromStore([this.ebOpts.meta]);
+      } else if (metas) {
+        await this.handleDbMetasFromStore(metas);
       }
-    }
-    return new keyedCrypto(url, rkey.Ok(), kb.rt.crypto, sthis);
+    });
   }
-  return new noCrypto(url, kb.rt.crypto, sthis);
-}
-
-// src/blockstore/fragment-gateway.ts
-var import_cement8 = require("@adviser/cement");
-var import_base584 = require("multiformats/bases/base58");
-var import_cborg = require("cborg");
-init_utils();
-function getFragSize(url) {
-  const fragSize = url.getParam("fragSize");
-  let ret = 0;
-  if (fragSize) {
-    ret = parseInt(fragSize);
+  async close() {
+    await this.commitQueue.waitIdle();
+    const toClose = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.WALStore()]);
+    await Promise.all(toClose.map((store) => store.close()));
   }
-  if (isNaN(ret) || ret <= 0) {
-    ret = 0;
+  async destroy() {
+    const toDestroy = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.WALStore()]);
+    await Promise.all(toDestroy.map((store) => store.destroy()));
   }
-  return ret;
-}
-async function getFrags(url, innerGW, headerSize, logger) {
-  const fragSize = getFragSize(url);
-  if (!fragSize) {
-    const res = await innerGW.get(url);
-    if (res.isErr()) {
-      return [res];
+  // async snapToCar(carCid: AnyLink | string) {
+  //   await this.ready
+  //   if (typeof carCid === 'string') {
+  //     carCid = CID.parse(carCid)
+  //   }
+  //   const carHeader = await this.loadCarHeaderFromMeta({ car: carCid, key: this.key || null })
+  //   this.carLog = [carCid, ...carHeader.cars]
+  //   await this.getMoreReaders(carHeader.cars)
+  //   await this._applyCarHeader(carHeader, true)
+  // }
+  async handleDbMetasFromStore(metas) {
+    this.logger.Debug().Any("metas", metas).Msg("handleDbMetasFromStore");
+    for (const meta of metas) {
+      await this.writeLimit(async () => {
+        await this.mergeDbMetaIntoClock(meta);
+      });
     }
-    const data = res.unwrap();
-    return [
-      import_cement8.Result.Ok({
-        fid: new Uint8Array(0),
-        ofs: 0,
-        len: data.length,
-        data
-      })
-    ];
-  }
-  const firstRaw = await innerGW.get(url.build().setParam("ofs", "0").URI());
-  if (firstRaw.isErr()) {
-    return [firstRaw];
-  }
-  const firstFragment = (0, import_cborg.decode)(firstRaw.unwrap());
-  const blockSize = firstFragment.data.length;
-  const ops = [Promise.resolve(import_cement8.Result.Ok(firstFragment))];
-  const fidStr = import_base584.base58btc.encode(firstFragment.fid);
-  const fragUrl = url.build().setParam("fid", fidStr).setParam("len", firstFragment.len.toString()).setParam("headerSize", headerSize.toString());
-  for (let ofs = blockSize; ofs < firstFragment.len; ofs += blockSize) {
-    ops.push(
-      (async (furl, ofs2) => {
-        const raw2 = await innerGW.get(furl);
-        if (raw2.isErr()) {
-          return raw2;
-        }
-        const fragment = (0, import_cborg.decode)(raw2.unwrap());
-        if (import_base584.base58btc.encode(fragment.fid) !== fidStr) {
-          return import_cement8.Result.Err(logger.Error().Msg("Fragment fid mismatch").AsError());
-        }
-        if (fragment.ofs !== ofs2) {
-          return import_cement8.Result.Err(logger.Error().Uint64("ofs", ofs2).Msg("Fragment ofs mismatch").AsError());
-        }
-        return import_cement8.Result.Ok(fragment);
-      })(fragUrl.setParam("ofs", ofs.toString()).URI(), ofs)
-    );
-  }
-  return Promise.all(ops);
-}
-var FragmentGateway = class {
-  constructor(sthis, innerGW) {
-    this.fidLength = 4;
-    this.headerSize = 32;
-    this.sthis = ensureSuperLog(sthis, "FragmentGateway");
-    this.logger = this.sthis.logger;
-    this.innerGW = innerGW;
   }
-  slicer(url, body) {
-    const fragSize = getFragSize(url);
-    if (!fragSize) {
-      return [this.innerGW.put(url, body)];
-    }
-    const blocksize = fragSize - this.headerSize;
-    if (blocksize <= 0) {
-      throw this.logger.Error().Uint64("fragSize", fragSize).Uint64("headerSize", this.headerSize).Msg("Fragment size is too small").AsError();
+  async mergeDbMetaIntoClock(meta) {
+    if (this.isCompacting) {
+      throw this.logger.Error().Msg("cannot merge while compacting").AsError();
     }
-    const ops = [];
-    const fid = this.sthis.nextId(this.fidLength);
-    const fragUrl = url.build().setParam("fid", fid.str).setParam("len", body.length.toString()).setParam("headerSize", this.headerSize.toString());
-    for (let ofs = 0; ofs < body.length; ofs += blocksize) {
-      const block = (0, import_cborg.encode)({
-        fid: fid.bin,
-        ofs,
-        len: body.length,
-        data: body.slice(ofs, ofs + blocksize)
-      });
-      if (block.length > fragSize) {
-        throw this.logger.Error().Uint64("block", block.length).Uint64("fragSize", fragSize).Msg("Block size to big").AsError();
-      }
-      ops.push(this.innerGW.put(fragUrl.setParam("ofs", ofs.toString()).URI(), block));
+    if (this.seenMeta.has(meta.cars.toString())) return;
+    this.seenMeta.add(meta.cars.toString());
+    if (carLogIncludesGroup(this.carLog, meta.cars)) {
+      return;
     }
-    return ops;
+    const carHeader = await this.loadCarHeaderFromMeta(meta);
+    carHeader.compact.map((c) => c.toString()).forEach(this.seenCompacted.add, this.seenCompacted);
+    await this.getMoreReaders(carHeader.cars.flat());
+    this.carLog = [...uniqueCids([meta.cars, ...this.carLog, ...carHeader.cars], this.seenCompacted)];
+    await this.ebOpts.applyMeta?.(carHeader.meta);
   }
-  buildUrl(baseUrl, key) {
-    return this.innerGW.buildUrl(baseUrl, key);
+  // protected async ingestKeyFromMeta(meta: DbMeta): Promise<void> {
+  //   const { key } = meta;
+  //   if (key) {
+  //     await this.setKey(key);
+  //   }
+  // }
+  async loadCarHeaderFromMeta({ cars: cids }) {
+    const reader = await this.loadCar(cids[0]);
+    return await parseCarFile(reader, this.logger);
   }
-  async destroy(iurl) {
-    return this.innerGW.destroy(iurl);
+  // async _getKey(): Promise<string | undefined> {
+  //   if (this.key) return this.key;
+  //   // generate a random key
+  //   if (!this.ebOpts.public) {
+  //     await this.setKey(toHexString(this.ebOpts.crypto.randomBytes(32)));
+  //   }
+  //   return this.key || undefined;
+  // }
+  async commitFiles(t, done) {
+    await this.ready();
+    const fstore = await this.fileStore();
+    const wstore = await this.WALStore();
+    return this.commitQueue.enqueue(() => commitFiles(fstore, wstore, t, done));
   }
-  async start(url) {
-    this.headerSize = (0, import_cborg.encode)({
-      fid: this.sthis.nextId(this.fidLength).bin,
-      ofs: 1024 * 1024,
-      // 32bit
-      len: 16 * 1024 * 1024,
-      // 32bit
-      data: new Uint8Array(1024)
-    }).length - 1024;
-    return this.innerGW.start(url);
+  async loadFileCar(cid) {
+    return await this.storesLoadCar(cid, await this.fileStore(), this.remoteFileStore);
   }
-  async close(url) {
-    return this.innerGW.close(url);
+  async commit(t, done, opts = { noLoader: false, compact: false }) {
+    await this.ready();
+    const carStore = await this.carStore();
+    const params = {
+      encoder: (await carStore.keyedCrypto()).codec(),
+      carLog: this.carLog,
+      carStore,
+      WALStore: await this.WALStore(),
+      metaStore: await this.metaStore(),
+      threshold: this.ebOpts.threshold
+    };
+    return this.commitQueue.enqueue(async () => {
+      await this.cacheTransaction(t);
+      const ret = await commit(params, t, done, opts);
+      await this.updateCarLog(ret.cgrp, ret.header, !!opts.compact);
+      return ret.cgrp;
+    });
   }
-  async put(url, body) {
-    await Promise.all(this.slicer(url, body));
-    return import_cement8.Result.Ok(void 0);
+  async updateCarLog(cids, fp, compact) {
+    if (compact) {
+      const previousCompactCid = fp.compact[fp.compact.length - 1];
+      fp.compact.map((c) => c.toString()).forEach(this.seenCompacted.add, this.seenCompacted);
+      this.carLog = [...uniqueCids([...this.carLog, ...fp.cars, cids], this.seenCompacted)];
+      await this.removeCidsForCompact(previousCompactCid[0]).catch((e) => e);
+    } else {
+      this.carLog.unshift(cids);
+    }
   }
-  async get(url) {
-    const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
-    let buffer = void 0;
-    for (const rfrag of rfrags) {
-      if (rfrag.isErr()) {
-        return import_cement8.Result.Err(rfrag.Err());
+  async cacheTransaction(t) {
+    for await (const block of t.entries()) {
+      const sBlock = block.cid.toString();
+      if (!this.getBlockCache.has(sBlock)) {
+        this.getBlockCache.set(sBlock, block);
+      }
+    }
+  }
+  async cacheCarReader(carCidStr, reader) {
+    if (this.processedCars.has(carCidStr)) return;
+    this.processedCars.add(carCidStr);
+    for await (const block of reader.blocks()) {
+      const sBlock = block.cid.toString();
+      if (!this.getBlockCache.has(sBlock)) {
+        this.getBlockCache.set(sBlock, block);
+      }
+    }
+  }
+  async removeCidsForCompact(cid) {
+    const carHeader = await this.loadCarHeaderFromMeta({
+      cars: [cid]
+    });
+    for (const cids of carHeader.compact) {
+      for (const cid2 of cids) {
+        await (await this.carStore()).remove(cid2);
       }
-      const frag = rfrag.Ok();
-      buffer = buffer || new Uint8Array(frag.len);
-      buffer.set(frag.data, frag.ofs);
     }
-    return import_cement8.Result.Ok(buffer || new Uint8Array(0));
   }
-  async subscribe(url, callback) {
-    if (this.innerGW.subscribe) {
-      return this.innerGW.subscribe(url, callback);
+  // async flushCars() {
+  //   await this.ready
+  //   // for each cid in car log, make a dbMeta
+  //   for (const cid of this.carLog) {
+  //     const dbMeta = { car: cid, key: this.key || null } as DbMeta
+  //     await this.remoteWAL!.enqueue(dbMeta, { public: false })
+  //   }
+  // }
+  async *entries(cache2 = true) {
+    await this.ready();
+    if (cache2) {
+      for (const [, block] of this.getBlockCache) {
+        yield block;
+      }
     } else {
-      return import_cement8.Result.Err(this.logger.Error().Url(url).Msg("subscribe not supported").AsError());
+      for (const [, block] of this.getBlockCache) {
+        yield block;
+      }
+      for (const cids of this.carLog) {
+        for (const cid of cids) {
+          const reader = await this.loadCar(cid);
+          if (!reader) throw this.logger.Error().Ref("cid", cid).Msg("missing car reader").AsError();
+          for await (const block of reader.blocks()) {
+            const sCid = block.cid.toString();
+            if (!this.getBlockCache.has(sCid)) {
+              yield block;
+            }
+          }
+        }
+      }
     }
   }
-  async delete(url) {
-    const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
-    for (const rfrag of rfrags) {
-      if (rfrag.isErr()) {
-        return import_cement8.Result.Err(rfrag.Err());
+  async getBlock(cid) {
+    await this.ready();
+    const sCid = cid.toString();
+    if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
+    const getCarCid = async (carCid) => {
+      if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
+      const reader = await this.loadCar(carCid);
+      if (!reader) {
+        throw this.logger.Error().Ref("cid", carCid).Msg("missing car reader").AsError();
       }
-      const frag = rfrag.Ok();
-      const fidStr = import_base584.base58btc.encode(frag.fid);
-      const fragUrl = url.build().setParam("fid", fidStr).setParam("len", frag.len.toString()).setParam("headerSize", this.headerSize.toString()).URI();
-      await this.innerGW.delete(fragUrl);
+      await this.cacheCarReader(carCid.toString(), reader).catch(() => {
+        return;
+      });
+      if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
+      throw this.logger.Error().Str("cid", sCid).Msg("block not in reader").AsError();
+    };
+    const getCompactCarCids = async (carCid) => {
+      const reader = await this.loadCar(carCid);
+      if (!reader) {
+        throw this.logger.Error().Str("cid", carCid.toString()).Msg("missing car reader").AsError();
+      }
+      const header = await parseCarFile(reader, this.logger);
+      const compacts = header.compact;
+      let got2;
+      const batchSize2 = 5;
+      for (let i = 0; i < compacts.length; i += batchSize2) {
+        const promises = [];
+        for (let j = i; j < Math.min(i + batchSize2, compacts.length); j++) {
+          for (const cid2 of compacts[j]) {
+            promises.push(getCarCid(cid2));
+          }
+        }
+        try {
+          got2 = await Promise.any(promises);
+        } catch {
+        }
+        if (got2) break;
+      }
+      if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
+      throw this.logger.Error().Str("cid", sCid).Msg("block not in compact reader").AsError();
+    };
+    let got;
+    const batchSize = 5;
+    for (let i = 0; i < this.carLog.length; i += batchSize) {
+      const batch = this.carLog.slice(i, i + batchSize);
+      const promises = batch.flatMap((slice) => slice.map(getCarCid));
+      try {
+        got = await Promise.any(promises);
+      } catch {
+      }
+      if (got) break;
     }
-    return import_cement8.Result.Ok(void 0);
-  }
-};
-
-// src/blockstore/meta-key-helper.ts
-var import_dag_json = require("@ipld/dag-json");
-var import_clock = require("@web3-storage/pail/clock");
-var import_multiformats2 = require("multiformats");
-var import_base64 = require("multiformats/bases/base64");
-var import_cement9 = require("@adviser/cement");
-async function decodeGatewayMetaBytesToDbMeta(sthis, byteHeads) {
-  const crdtEntries = JSON.parse(sthis.txt.decode(byteHeads));
-  if (!crdtEntries.length) {
-    sthis.logger.Debug().Str("byteHeads", new TextDecoder().decode(byteHeads)).Msg("No CRDT entries found");
-    return [];
+    if (!got) {
+      try {
+        got = await getCompactCarCids(this.carLog[this.carLog.length - 1][0]);
+      } catch {
+      }
+    }
+    return got;
   }
-  if (!crdtEntries.map) {
-    sthis.logger.Debug().Str("crdtEntries", JSON.stringify(crdtEntries)).Msg("No data in CRDT entries");
-    return [];
+  async loadCar(cid) {
+    if (!this.carStore) {
+      throw this.logger.Error().Msg("car store not initialized").AsError();
+    }
+    const loaded = await this.storesLoadCar(cid, await this.carStore(), this.remoteCarStore);
+    return loaded;
   }
-  return Promise.all(
-    crdtEntries.map(async (crdtEntry) => {
-      const eventBlock = await (0, import_clock.decodeEventBlock)(import_base64.base64pad.decode(crdtEntry.data));
-      const dbMeta = (0, import_dag_json.parse)(sthis.txt.decode(eventBlock.value.data.dbMeta));
-      return {
-        eventCid: eventBlock.cid,
-        parents: crdtEntry.parents,
-        dbMeta
-      };
-    })
-  );
-}
-async function setCryptoKeyFromGatewayMetaPayload(uri, sthis, data) {
-  try {
-    sthis.logger.Debug().Str("uri", uri.toString()).Msg("Setting crypto key from gateway meta payload");
-    const keyInfo = await decodeGatewayMetaBytesToDbMeta(sthis, data);
-    if (keyInfo.length) {
-      const dbMeta = keyInfo[0].dbMeta;
-      if (dbMeta.key) {
-        const kb = await getKeyBag(sthis);
-        const keyName = getStoreKeyName(uri);
-        const res = await kb.setNamedKey(keyName, dbMeta.key);
-        if (res.isErr()) {
-          sthis.logger.Debug().Str("keyName", keyName).Str("dbMeta.key", dbMeta.key).Msg("Failed to set named key");
-          throw res.Err();
+  async makeDecoderAndCarReader(cid, local, remote) {
+    const cidsString = cid.toString();
+    let loadedCar = void 0;
+    let activeStore = local;
+    try {
+      this.logger.Debug().Str("cid", cidsString).Msg("loading car");
+      loadedCar = await local.load(cid);
+      this.logger.Debug().Bool("loadedCar", loadedCar).Msg("loaded");
+    } catch (e) {
+      if (remote) {
+        const remoteCar = await remote.load(cid);
+        if (remoteCar) {
+          this.logger.Debug().Ref("cid", remoteCar.cid).Msg("saving remote car locally");
+          await local.save(remoteCar);
+          loadedCar = remoteCar;
+          activeStore = remote;
         }
+      } else {
+        this.logger.Error().Str("cid", cidsString).Err(e).Msg("loading car");
       }
-      sthis.logger.Debug().Str("dbMeta.key", dbMeta.key).Str("uri", uri.toString()).Msg("Set crypto key from gateway meta payload");
-      return import_cement9.Result.Ok(dbMeta);
     }
-    sthis.logger.Debug().Str("data", new TextDecoder().decode(data)).Msg("No crypto in gateway meta payload");
-    return import_cement9.Result.Ok(void 0);
-  } catch (error) {
-    sthis.logger.Debug().Err(error).Msg("Failed to set crypto key from gateway meta payload");
-    return import_cement9.Result.Err(error);
+    if (!loadedCar) {
+      throw this.logger.Error().Url(local.url()).Str("cid", cidsString).Msg("missing car files").AsError();
+    }
+    const bytes = await decode3({ bytes: loadedCar.bytes, hasher: import_sha24.sha256, codec: (await activeStore.keyedCrypto()).codec() });
+    const rawReader = await import_car.CarReader.fromBytes(bytes.value);
+    const readerP = Promise.resolve(rawReader);
+    const cachedReaderP = readerP.then(async (reader) => {
+      await this.cacheCarReader(cidsString, reader).catch((e) => {
+        this.logger.Error().Err(e).Str("cid", cidsString).Msg("error caching car reader");
+        return;
+      });
+      return reader;
+    });
+    this.carReaders.set(cidsString, cachedReaderP);
+    return readerP;
   }
-}
-async function addCryptoKeyToGatewayMetaPayload(uri, sthis, body) {
-  try {
-    sthis.logger.Debug().Str("uri", uri.toString()).Msg("Adding crypto key to gateway meta payload");
-    const keyName = getStoreKeyName(uri);
-    const kb = await getKeyBag(sthis);
-    const res = await kb.getNamedExtractableKey(keyName, true);
-    if (res.isErr()) {
-      sthis.logger.Error().Str("keyName", keyName).Msg("Failed to get named extractable key");
-      throw res.Err();
+  //What if instead it returns an Array of CarHeader
+  async storesLoadCar(cid, local, remote) {
+    const cidsString = cid.toString();
+    let dacr = this.carReaders.get(cidsString);
+    if (!dacr) {
+      dacr = this.makeDecoderAndCarReader(cid, local, remote);
+      this.carReaders.set(cidsString, dacr);
     }
-    const keyData = await res.Ok().extract();
-    const dbMetas = await decodeGatewayMetaBytesToDbMeta(sthis, body);
-    const { dbMeta, parents } = dbMetas[0];
-    const parentLinks = parents.map((p) => import_multiformats2.CID.parse(p));
-    dbMeta.key = keyData.keyStr;
-    const events = await Promise.all([dbMeta].map((dbMeta2) => createDbMetaEventBlock(sthis, dbMeta2, parentLinks)));
-    const encoded = await encodeEventsWithParents(sthis, events, parentLinks);
-    sthis.logger.Debug().Str("uri", uri.toString()).Msg("Added crypto key to gateway meta payload");
-    return import_cement9.Result.Ok(encoded);
-  } catch (error) {
-    sthis.logger.Error().Err(error).Msg("Failed to add crypto key to gateway meta payload");
-    return import_cement9.Result.Err(error);
+    return dacr;
   }
-}
-function getStoreKeyName(url) {
-  const storeKeyName = [url.getParam("localName") || url.getParam("name")];
-  const idx = url.getParam("index");
-  if (idx) {
-    storeKeyName.push(idx);
+  async getMoreReaders(cids) {
+    const limit = (0, import_p_limit.default)(5);
+    const missing = cids.filter((cid) => !this.carReaders.has(cid.toString()));
+    await Promise.all(missing.map((cid) => limit(() => this.loadCar(cid))));
   }
-  storeKeyName.push("data");
-  return `@${storeKeyName.join(":")}@`;
-}
-async function createDbMetaEventBlock(sthis, dbMeta, parents) {
-  const event = await import_clock.EventBlock.create(
-    {
-      dbMeta: sthis.txt.encode((0, import_dag_json.format)(dbMeta))
-    },
-    parents
-  );
-  return event;
-}
-async function encodeEventsWithParents(sthis, events, parents) {
-  const crdtEntries = events.map((event) => {
-    const base64String = import_base64.base64pad.encode(event.bytes);
-    return {
-      cid: event.cid.toString(),
-      data: base64String,
-      parents: parents.map((p) => p.toString())
-    };
-  });
-  return sthis.txt.encode(JSON.stringify(crdtEntries));
-}
+};
 
 // src/blockstore/store.ts
 function guardVersion(url) {
@@ -2571,16 +2714,21 @@ function guardVersion(url) {
   return import_cement10.Result.Ok(url);
 }
 var BaseStoreImpl = class {
-  constructor(name, url, opts, sthis, logger) {
+  constructor(sthis, url, opts, logger) {
     this._onStarted = [];
     this._onClosed = [];
-    this.name = name;
     this._url = url;
     this.keybag = opts.keybag;
+    this.loader = opts.loader;
     this.sthis = sthis;
-    this.logger = logger.With().Ref("url", () => this._url.toString()).Str("name", name).Logger();
+    const name = this._url.getParam("name" /* NAME */);
+    if (!name) {
+      throw logger.Error().Str("url", this._url.toString()).Msg("missing name").AsError();
+    }
+    this.name = name;
+    this.logger = logger.With().Str("this", this.sthis.nextId().str).Ref("url", () => this._url.toString()).Logger();
+    this.realGateway = opts.gateway;
     this.gateway = new FragmentGateway(this.sthis, opts.gateway);
-    this.loader = opts.loader;
   }
   url() {
     return this._url;
@@ -2595,20 +2743,20 @@ var BaseStoreImpl = class {
     return;
   }
   async keyedCrypto() {
-    return keyedCryptoFactory(this._url, await this.keybag(), this.sthis);
+    return keyedCryptoFactory(this._url, this.keybag, this.sthis);
   }
   async start() {
     this.logger.Debug().Str("storeType", this.storeType).Msg("starting-gateway-pre");
-    this._url = this._url.build().setParam("store", this.storeType).URI();
+    this._url = this._url.build().setParam("store" /* STORE */, this.storeType).URI();
     const res = await this.gateway.start(this._url);
     if (res.isErr()) {
       this.logger.Error().Result("gw-start", res).Msg("started-gateway");
       return res;
     }
     this._url = res.Ok();
-    const kb = await this.keybag();
+    const kb = await this.keybag;
     const skRes = await kb.ensureKeyFromUrl(this._url, () => {
-      const idx = this._url.getParam("index");
+      const idx = this._url.getParam("index" /* INDEX */);
       const storeKeyName = [this.name];
       if (idx) {
         storeKeyName.push(idx);
@@ -2641,8 +2789,8 @@ var BaseStoreImpl = class {
 };
 var MetaStoreImpl = class extends BaseStoreImpl {
   // remote: boolean;
-  constructor(sthis, name, url, opts) {
-    super(name, url, { ...opts }, sthis, ensureLogger(sthis, "MetaStoreImpl"));
+  constructor(sthis, url, opts) {
+    super(sthis, url, { ...opts }, ensureLogger(sthis, "MetaStoreImpl"));
     this.storeType = "meta";
     this.subscribers = /* @__PURE__ */ new Map();
     this.parents = [];
@@ -2713,13 +2861,21 @@ var MetaStoreImpl = class extends BaseStoreImpl {
     return import_cement10.Result.Ok(void 0);
   }
   async destroy() {
+    this.logger.Debug().Msg("destroy");
     return this.gateway.destroy(this.url());
   }
 };
 var DataStoreImpl = class extends BaseStoreImpl {
   // readonly tag: string = "car-base";
-  constructor(sthis, name, url, opts) {
-    super(name, url, { ...opts }, sthis, ensureLogger(sthis, "DataStoreImpl"));
+  constructor(sthis, url, opts) {
+    super(
+      sthis,
+      url,
+      {
+        ...opts
+      },
+      ensureLogger(sthis, "DataStoreImpl")
+    );
     this.storeType = "data";
   }
   async load(cid) {
@@ -2760,23 +2916,32 @@ var DataStoreImpl = class extends BaseStoreImpl {
     return import_cement10.Result.Ok(void 0);
   }
   destroy() {
+    this.logger.Debug().Msg("destroy");
     return this.gateway.destroy(this.url());
   }
 };
 var WALStoreImpl = class extends BaseStoreImpl {
-  constructor(loader, url, opts) {
-    super(loader.name, url, { ...opts }, loader.sthis, ensureLogger(loader.sthis, "WALStoreImpl"));
+  constructor(sthis, url, opts) {
+    super(
+      sthis,
+      url,
+      {
+        ...opts
+      },
+      ensureLogger(sthis, "WALStoreImpl")
+    );
     this.storeType = "wal";
+    // readonly tag: string = "rwal-base";
+    // readonly loader: Loadable;
     this._ready = new import_cement10.ResolveOnce();
     this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
     this.processing = void 0;
     this.processQueue = new CommitQueue();
-    this.loader = loader;
   }
   async ready() {
     return this._ready.once(async () => {
       const walState = await this.load().catch((e) => {
-        this.logger.Error().Any("error", e).Msg("error loading wal");
+        this.logger.Error().Err(e).Msg("error loading wal");
         return void 0;
       });
       if (!walState) {
@@ -2809,7 +2974,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
   }
   async process() {
     await this.ready();
-    if (!this.loader.remoteCarStore) return;
+    if (!this.loader?.remoteCarStore) return;
     await this.processQueue.enqueue(async () => {
       try {
         await this._doProcess();
@@ -2822,73 +2987,88 @@ var WALStoreImpl = class extends BaseStoreImpl {
     });
   }
   async _doProcess() {
+    if (!this.loader) return;
     if (!this.loader.remoteCarStore) return;
-    const rmlp = (async () => {
-      const operations = [...this.walState.operations];
-      const fileOperations = [...this.walState.fileOperations];
-      const uploads = [];
-      const noLoaderOps = [...this.walState.noLoaderOps];
-      const limit = (0, import_p_limit2.default)(3);
-      if (operations.length + fileOperations.length + noLoaderOps.length === 0) return;
-      for (const dbMeta of noLoaderOps) {
-        const uploadP = limit(async () => {
-          for (const cid of dbMeta.cars) {
-            const car = await (await this.loader.carStore()).load(cid);
-            if (!car) {
-              if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars))
-                throw this.logger.Error().Ref("cid", cid).Msg("missing local car").AsError();
-            } else {
-              await throwFalsy(this.loader.remoteCarStore).save(car);
+    const operations = [...this.walState.operations];
+    const noLoaderOps = [...this.walState.noLoaderOps];
+    const fileOperations = [...this.walState.fileOperations];
+    if (operations.length + noLoaderOps.length + fileOperations.length === 0) return;
+    const concurrencyLimit = 3;
+    const retryableUpload = (fn, description) => (0, import_p_retry.default)(fn, {
+      retries: 5,
+      onFailedAttempt: (error) => {
+        this.logger.Warn().Msg(`Attempt ${error.attemptNumber} failed for ${description}. There are ${error.retriesLeft} retries left.`);
+      }
+    });
+    try {
+      await (0, import_p_map.default)(
+        noLoaderOps,
+        async (dbMeta) => {
+          await retryableUpload(async () => {
+            if (!this.loader) return;
+            for (const cid of dbMeta.cars) {
+              const car = await (await this.loader.carStore()).load(cid);
+              if (!car) {
+                if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars)) {
+                  throw this.logger.Error().Ref("cid", cid).Msg("missing local car").AsError();
+                }
+              } else {
+                await throwFalsy(this.loader.remoteCarStore).save(car);
+              }
             }
             this.walState.noLoaderOps = this.walState.noLoaderOps.filter((op) => op !== dbMeta);
-          }
-        });
-        uploads.push(uploadP);
-      }
-      for (const dbMeta of operations) {
-        const uploadP = limit(async () => {
-          for (const cid of dbMeta.cars) {
-            const car = await (await this.loader.carStore()).load(cid).catch(() => null);
-            if (!car) {
-              if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars))
-                throw this.logger.Error().Ref("cid", cid).Msg(`missing local car`).AsError();
-            } else {
-              await throwFalsy(this.loader.remoteCarStore).save(car);
+          }, `noLoaderOp with dbMeta.cars=${dbMeta.cars.toString()}`);
+        },
+        { concurrency: concurrencyLimit }
+      );
+      await (0, import_p_map.default)(
+        operations,
+        async (dbMeta) => {
+          await retryableUpload(async () => {
+            if (!this.loader) return;
+            for (const cid of dbMeta.cars) {
+              const car = await (await this.loader.carStore()).load(cid);
+              if (!car) {
+                if (carLogIncludesGroup(this.loader.carLog, dbMeta.cars)) {
+                  throw this.logger.Error().Ref("cid", cid).Msg(`missing local car`).AsError();
+                }
+              } else {
+                await throwFalsy(this.loader.remoteCarStore).save(car);
+              }
             }
-          }
-          this.walState.operations = this.walState.operations.filter((op) => op !== dbMeta);
-        });
-        uploads.push(uploadP);
-      }
-      if (fileOperations.length) {
-        const dbLoader = this.loader;
-        for (const { cid: fileCid, public: publicFile } of fileOperations) {
-          const uploadP = limit(async () => {
-            const fileBlock = await (await dbLoader.fileStore()).load(fileCid);
-            await dbLoader.remoteFileStore?.save(fileBlock, { public: publicFile });
+            this.walState.operations = this.walState.operations.filter((op) => op !== dbMeta);
+          }, `operation with dbMeta.cars=${dbMeta.cars.toString()}`);
+        },
+        { concurrency: concurrencyLimit }
+      );
+      await (0, import_p_map.default)(
+        fileOperations,
+        async ({ cid: fileCid, public: publicFile }) => {
+          await retryableUpload(async () => {
+            if (!this.loader) return;
+            const fileBlock = await (await this.loader.fileStore()).load(fileCid);
+            if (!fileBlock) {
+              throw this.logger.Error().Ref("cid", fileCid).Msg("missing file block").AsError();
+            }
+            await this.loader.remoteFileStore?.save(fileBlock, { public: publicFile });
             this.walState.fileOperations = this.walState.fileOperations.filter((op) => op.cid !== fileCid);
-          });
-          uploads.push(uploadP);
-        }
-      }
-      try {
-        const res = await Promise.allSettled(uploads);
-        const errors = res.filter((r) => r.status === "rejected");
-        if (errors.length) {
-          throw this.logger.Error().Any("errors", errors).Msg("error uploading").AsError();
-        }
-        if (operations.length) {
-          const lastOp = operations[operations.length - 1];
-          await this.loader.remoteMetaStore?.save(lastOp).catch((e) => {
-            this.walState.operations.push(lastOp);
-            throw this.logger.Error().Any("error", e).Msg("error saving remote meta").AsError();
-          });
-        }
-      } finally {
-        await this.save(this.walState);
+          }, `fileOperation with cid=${fileCid.toString()}`);
+        },
+        { concurrency: concurrencyLimit }
+      );
+      if (operations.length) {
+        const lastOp = operations[operations.length - 1];
+        await retryableUpload(async () => {
+          if (!this.loader) return;
+          await this.loader.remoteMetaStore?.save(lastOp);
+        }, `remoteMetaStore save with dbMeta.cars=${lastOp.cars.toString()}`);
       }
-    })();
-    await rmlp;
+    } catch (error) {
+      this.logger.Error().Any("error", error).Msg("Processing failed");
+      return;
+    } finally {
+      await this.save(this.walState);
+    }
   }
   async load() {
     this.logger.Debug().Msg("loading");
@@ -2905,6 +3085,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
     }
     try {
       return bytes && (0, import_dag_json2.parse)(this.sthis.txt.decode(bytes.Ok()));
+      return bytes && (0, import_dag_json2.parse)(this.sthis.txt.decode(bytes.Ok()));
     } catch (e) {
       throw this.logger.Error().Err(e).Msg("error parse").AsError();
     }
@@ -2931,73 +3112,98 @@ var WALStoreImpl = class extends BaseStoreImpl {
     return import_cement10.Result.Ok(void 0);
   }
   destroy() {
+    this.logger.Debug().Msg("destroy");
     return this.gateway.destroy(this.url());
   }
 };
 
 // src/blockstore/store-factory.ts
+init_types();
+
+// src/blockstore/register-store-protocol.ts
+var import_cement14 = require("@adviser/cement");
+init_version();
+
+// src/runtime/gateways/memory/gateway.ts
+var import_cement11 = require("@adviser/cement");
+init_types();
+
+// src/runtime/gateways/memory/version.ts
+var MEMORY_VERSION = "v0.19-memory";
+
+// src/runtime/gateways/memory/gateway.ts
 init_utils();
-function ensureIsIndex(url, isIndex) {
-  if (isIndex) {
-    return url.build().setParam("index", isIndex).URI();
+var MemoryGateway = class {
+  constructor(memorys) {
+    this.memorys = memorys;
   }
-  return url.build().delParam("index").URI();
-}
-function ensureName(name, url) {
-  if (!url.hasParam("name")) {
-    return url.build().setParam("name", name).URI();
+  buildUrl(baseUrl, key) {
+    return Promise.resolve(import_cement11.Result.Ok(baseUrl.build().setParam("key" /* KEY */, key).URI()));
   }
-  return url;
-}
+  start(baseUrl) {
+    return Promise.resolve(import_cement11.Result.Ok(baseUrl.build().setParam("version" /* VERSION */, MEMORY_VERSION).URI()));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  close(baseUrl) {
+    return Promise.resolve(import_cement11.Result.Ok(void 0));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  destroy(baseUrl) {
+    this.memorys.clear();
+    return Promise.resolve(import_cement11.Result.Ok(void 0));
+  }
+  put(url, body) {
+    this.memorys.set(url.toString(), body);
+    return Promise.resolve(import_cement11.Result.Ok(void 0));
+  }
+  // get could return a NotFoundError if the key is not found
+  get(url) {
+    const x = this.memorys.get(url.toString());
+    if (x === void 0) {
+      return Promise.resolve(import_cement11.Result.Err(new NotFoundError("not found")));
+    }
+    return Promise.resolve(import_cement11.Result.Ok(x));
+  }
+  delete(url) {
+    this.memorys.delete(url.toString());
+    return Promise.resolve(import_cement11.Result.Ok(void 0));
+  }
+};
+var MemoryTestGateway = class {
+  constructor(memorys) {
+    this.memorys = memorys;
+  }
+  async get(url, key) {
+    return this.memorys.get(url.build().setParam("key" /* KEY */, key).toString());
+  }
+};
+
+// src/blockstore/register-store-protocol.ts
 var storeFactory = /* @__PURE__ */ new Map();
-function buildURL(optURL, loader) {
-  const storeOpts = loader.ebOpts.store;
-  const obuItem = Array.from(storeFactory.values()).find((items) => items.overrideBaseURL);
-  let obuUrl;
-  if (obuItem && obuItem.overrideBaseURL) {
-    obuUrl = import_cement13.URI.from(obuItem.overrideBaseURL);
-  }
-  const ret = ensureIsIndex(
-    import_cement13.URI.from(optURL || obuUrl || dataDir(loader.sthis, loader.name, storeOpts.stores?.base)),
-    storeOpts.isIndex
-  );
-  return ret;
-}
-var onceGateway = new import_cement13.KeyedResolvOnce();
-async function getGatewayFromURL(url, sthis) {
-  return onceGateway.get(url.toString()).once(async () => {
-    const item = storeFactory.get(url.protocol);
-    if (item) {
-      const ret = {
-        gateway: await item.gateway(sthis),
-        test: await item.test(sthis)
-      };
-      const res = await ret.gateway.start(url);
-      if (res.isErr()) {
-        sthis.logger.Error().Result("start", res).Msg("start failed");
-        return void 0;
-      }
-      return ret;
+function getDefaultURI(sthis, protocol) {
+  if (protocol) {
+    if (!protocol.endsWith(":")) {
+      protocol += ":";
     }
-    sthis.logger.Warn().Url(url).Msg("unsupported protocol");
-    return void 0;
-  });
+    const gfi = storeFactory.get(protocol);
+    if (gfi) {
+      return gfi.defaultURI(sthis);
+    }
+  }
+  const found = Array.from(storeFactory.values()).find((item) => item.isDefault);
+  if (!found) {
+    throw sthis.logger.Error().Msg("no default found").AsError();
+  }
+  return found.defaultURI(sthis);
 }
 function registerStoreProtocol(item) {
   let protocol = item.protocol;
   if (!protocol.endsWith(":")) {
     protocol += ":";
   }
-  if (storeFactory.has(protocol)) {
-    if (!item.overrideBaseURL && storeFactory.get(protocol) !== item) {
-      throw new Error(`we need a logger here`);
-      return () => {
-      };
-    }
-  }
-  if (item.overrideBaseURL) {
+  if (item.isDefault) {
     Array.from(storeFactory.values()).forEach((items) => {
-      items.overrideBaseURL = void 0;
+      items.isDefault = false;
     });
   }
   storeFactory.set(protocol, item);
@@ -3005,134 +3211,186 @@ function registerStoreProtocol(item) {
     storeFactory.delete(protocol);
   };
 }
-var onceDataStoreFactory = new import_cement13.KeyedResolvOnce();
-async function dataStoreFactory(loader) {
-  const url = ensureName(loader.name, buildURL(loader.ebOpts.store.stores?.data, loader)).build().setParam("store", "data").URI();
-  const sthis = ensureSuperLog(loader.sthis, "dataStoreFactory", { url: url.toString() });
-  return onceDataStoreFactory.get(url.toString()).once(async () => {
-    const gateway = await getGatewayFromURL(url, sthis);
-    if (!gateway) {
-      throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
-    }
-    const store = new DataStoreImpl(sthis, loader.name, url, {
-      gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, {
-        ...loader.ebOpts.keyBag
-      })
-    });
-    return store;
+function getGatewayFactoryItem(protocol) {
+  return storeFactory.get(protocol);
+}
+function fileGatewayFactoryItem() {
+  return {
+    protocol: "file:",
+    isDefault: true,
+    defaultURI: (sthis) => {
+      return import_cement14.BuildURI.from("file://").pathname(`${sthis.env.get("HOME")}/.fireproof/${FILESTORE_VERSION.replace(/-.*$/, "")}`).URI();
+    },
+    gateway: async (sthis) => {
+      const { FileGateway: FileGateway2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
+      return new FileGateway2(sthis);
+    },
+    test: async (sthis) => {
+      const { FileTestStore: FileTestStore2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
+      return new FileTestStore2(sthis);
+    }
+  };
+}
+if ((0, import_cement14.runtimeFn)().isBrowser) {
+  registerStoreProtocol({
+    protocol: "indexdb:",
+    isDefault: true,
+    defaultURI: () => {
+      return import_cement14.BuildURI.from("indexdb://").pathname("fp").URI();
+    },
+    gateway: async (logger) => {
+      const { IndexDBGateway: IndexDBGateway2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
+      return new IndexDBGateway2(logger);
+    },
+    test: async (logger) => {
+      const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
+      return new IndexDBTestStore2(logger);
+    }
   });
+} else {
+  registerStoreProtocol(fileGatewayFactoryItem());
 }
-var onceMetaStoreFactory = new import_cement13.KeyedResolvOnce();
-async function metaStoreFactory(loader) {
-  const url = ensureName(loader.name, buildURL(loader.ebOpts.store.stores?.meta, loader)).build().setParam("store", "meta").URI();
-  const sthis = ensureSuperLog(loader.sthis, "metaStoreFactory", { url: () => url.toString() });
-  return onceMetaStoreFactory.get(url.toString()).once(async () => {
-    sthis.logger.Debug().Str("protocol", url.protocol).Msg("pre-protocol switch");
-    const gateway = await getGatewayFromURL(url, sthis);
-    if (!gateway) {
-      throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
-    }
-    const store = new MetaStoreImpl(loader.sthis, loader.name, url, {
-      gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, {
-        ...loader.ebOpts.keyBag
-      })
-    });
-    return store;
+var memory = /* @__PURE__ */ new Map();
+registerStoreProtocol({
+  protocol: "memory:",
+  isDefault: false,
+  defaultURI: () => {
+    return import_cement14.BuildURI.from("memory://").pathname("ram").URI();
+  },
+  gateway: async () => {
+    return new MemoryGateway(memory);
+  },
+  test: async () => {
+    return new MemoryTestGateway(memory);
+  }
+});
+
+// src/blockstore/store-factory.ts
+var onceGateway = new import_cement15.KeyedResolvOnce();
+var gatewayInstances = new import_cement15.KeyedResolvOnce();
+async function getStartedGateway(sthis, url) {
+  return onceGateway.get(url.toString()).once(async () => {
+    const item = getGatewayFactoryItem(url.protocol);
+    if (item) {
+      const ret = {
+        url,
+        ...await gatewayInstances.get(url.protocol).once(async () => ({
+          gateway: await item.gateway(sthis),
+          test: await item.test(sthis)
+        }))
+      };
+      const res = await ret.gateway.start(url);
+      if (res.isErr()) {
+        return import_cement15.Result.Err(sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
+      }
+      ret.url = res.Ok();
+      return import_cement15.Result.Ok(ret);
+    }
+    return import_cement15.Result.Err(sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
   });
 }
-var onceRemoteWalFactory = new import_cement13.KeyedResolvOnce();
-async function remoteWalFactory(loader) {
-  const url = ensureName(loader.name, buildURL(loader.ebOpts.store.stores?.wal, loader)).build().setParam("store", "wal").URI();
-  const sthis = ensureSuperLog(loader.sthis, "remoteWalFactory", { url: url.toString() });
-  return onceRemoteWalFactory.get(url.toString()).once(async () => {
-    const gateway = await getGatewayFromURL(url, sthis);
-    if (!gateway) {
-      throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
-    }
-    sthis.logger.Debug().Str("prepared", url.toString()).Msg("produced");
-    const store = new WALStoreImpl(loader, url, {
-      gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, {
-        ...loader.ebOpts.keyBag
-      })
-    });
-    return store;
+async function dataStoreFactory(sfi) {
+  const storeUrl = sfi.url.build().setParam("store" /* STORE */, "data").URI();
+  const rgateway = await getStartedGateway(sfi.sthis, storeUrl);
+  if (rgateway.isErr()) {
+    throw sfi.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+  }
+  const gateway = rgateway.Ok();
+  const store = new DataStoreImpl(sfi.sthis, gateway.url, {
+    gateway: gateway.gateway,
+    keybag: sfi.keybag
+  });
+  return store;
+}
+async function metaStoreFactory(sfi) {
+  const storeUrl = sfi.url.build().setParam("store" /* STORE */, "meta").URI();
+  const rgateway = await getStartedGateway(sfi.sthis, storeUrl);
+  if (rgateway.isErr()) {
+    throw sfi.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+  }
+  const gateway = rgateway.Ok();
+  const store = new MetaStoreImpl(sfi.sthis, gateway.url, {
+    gateway: gateway.gateway,
+    keybag: sfi.keybag
   });
+  return store;
+}
+async function WALStoreFactory(sfi) {
+  const storeUrl = sfi.url.build().setParam("store" /* STORE */, "wal").URI();
+  const rgateway = await getStartedGateway(sfi.sthis, storeUrl);
+  if (rgateway.isErr()) {
+    throw sfi.sthis.logger.Error().Result("err", rgateway).Url(sfi.url).Msg("notfound").AsError();
+  }
+  const gateway = rgateway.Ok();
+  const store = new WALStoreImpl(sfi.sthis, gateway.url, {
+    gateway: gateway.gateway,
+    keybag: sfi.keybag
+  });
+  return store;
 }
 async function testStoreFactory(url, sthis) {
-  sthis = ensureSuperLog(sthis, "testStoreFactory");
-  const gateway = await getGatewayFromURL(url, sthis);
-  if (!gateway) {
+  const rgateway = await getStartedGateway(sthis, url);
+  if (!rgateway) {
     throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
   }
-  return gateway.test;
+  return rgateway.Ok().test;
 }
-async function ensureStart(store, logger) {
+async function ensureStart(store) {
   const ret = await store.start();
   if (ret.isErr()) {
-    throw logger.Error().Result("start", ret).Msg("start failed").AsError();
+    throw store.logger.Error().Result("start", ret).Msg("start failed").AsError();
   }
-  logger.Debug().Url(ret.Ok(), "prepared").Msg("produced");
+  store.logger.Debug().Url(ret.Ok(), "prepared").Msg("produced");
   return store;
 }
-function toStoreRuntime(opts, sthis) {
-  const logger = ensureLogger(sthis, "toStoreRuntime", {});
+function ensureStoreEnDeFile(ende) {
+  ende = ende || {};
   return {
-    makeMetaStore: async (loader) => {
-      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeMetaStore).Msg("makeMetaStore");
-      return ensureStart(await (loader.ebOpts.store.makeMetaStore || metaStoreFactory)(loader), logger);
-    },
-    makeDataStore: async (loader) => {
-      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeDataStore).Msg("makeDataStore");
-      return ensureStart(await (loader.ebOpts.store.makeDataStore || dataStoreFactory)(loader), logger);
-    },
-    makeWALStore: async (loader) => {
-      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeWALStore).Msg("makeRemoteWAL");
-      return ensureStart(await (loader.ebOpts.store.makeWALStore || remoteWalFactory)(loader), logger);
-    },
-    encodeFile: opts.encodeFile || encodeFile,
-    decodeFile: opts.decodeFile || decodeFile
+    encodeFile: ende.encodeFile || encodeFile,
+    decodeFile: ende.decodeFile || decodeFile
   };
 }
-registerStoreProtocol({
-  protocol: "file:",
-  gateway: async (sthis) => {
-    const { FileGateway: FileGateway2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
-    return new FileGateway2(sthis);
-  },
-  test: async (sthis) => {
-    const { FileTestStore: FileTestStore2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
-    return new FileTestStore2(sthis);
-  }
-});
-registerStoreProtocol({
-  protocol: "indexdb:",
-  gateway: async (sthis) => {
-    const { IndexDBGateway: IndexDBGateway2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
-    return new IndexDBGateway2(sthis);
-  },
-  test: async (sthis) => {
-    const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
-    return new IndexDBTestStore2(sthis);
-  }
-});
+function toStoreRuntime(sthis, endeOpts = {}) {
+  return {
+    makeMetaStore: async (sfi) => ensureStart(await metaStoreFactory(sfi)),
+    // async (loader: Loadable) => {
+    //   logger
+    //     .Debug()
+    //     .Str("fromOpts", "" + !!endeOpts.func?.makeMetaStore)
+    //     .Msg("makeMetaStore");
+    //   return ensureStart(await (endeOpts.func?.makeMetaStore || metaStoreFactory)(loader), logger);
+    // },
+    makeDataStore: async (sfi) => ensureStart(await dataStoreFactory(sfi)),
+    // async (loader: Loadable) => {
+    //   logger
+    //     .Debug()
+    //     .Str("fromOpts", "" + !!endeOpts.func?.makeDataStore)
+    //     .Msg("makeDataStore");
+    //   return ensureStart(await (endeOpts.func?.makeDataStore || dataStoreFactory)(loader), logger);
+    // },
+    makeWALStore: async (sfi) => ensureStart(await WALStoreFactory(sfi)),
+    // async (loader: Loadable) => {
+    //   logger
+    //     .Debug()
+    //     .Str("fromOpts", "" + !!endeOpts.func?.makeWALStore)
+    //     .Msg("makeRemoteWAL");
+    //   return ensureStart(await (endeOpts.func?.makeWALStore || remoteWalFactory)(loader), logger);
+    // },
+    ...ensureStoreEnDeFile(endeOpts)
+  };
+}
+
+// src/blockstore/connection-base.ts
+init_types();
 
 // src/blockstore/store-remote.ts
 async function RemoteDataStore(sthis, name, url, opts) {
-  const ds = new DataStoreImpl(sthis, name, url, opts);
+  const ds = new DataStoreImpl(sthis, url, opts);
   await ds.start();
   return ds;
 }
 async function RemoteMetaStore(sthis, name, url, opts) {
-  const ms = new MetaStoreImpl(
-    sthis,
-    name,
-    url,
-    opts
-    /* , true*/
-  );
+  const ms = new MetaStoreImpl(sthis, url, opts);
   await ms.start();
   return ms;
 }
@@ -3157,14 +3415,17 @@ var ConnectionBase = class {
     if (!loader) throw this.logger.Error().Msg("connectMeta_X: loader is required").AsError();
     this.loader = loader;
     await this.onConnect();
-    const metaUrl = this.url.build().defParam("store", "meta").URI();
-    const gateway = await getGatewayFromURL(metaUrl, this.loader.sthis);
-    if (!gateway) throw this.logger.Error().Url(metaUrl).Msg("connectMeta_X: gateway is required").AsError();
+    const metaUrl = this.url.build().defParam("store" /* STORE */, "meta").URI();
+    const rgateway = await getStartedGateway(loader.sthis, metaUrl);
+    if (rgateway.isErr())
+      throw this.logger.Error().Result("err", rgateway).Url(metaUrl).Msg("connectMeta_X: gateway is required").AsError();
+    const name = metaUrl.toString();
     const dbName = metaUrl.getParam("name");
-    if (!dbName) throw this.logger.Error().Url(metaUrl).Msg("connectMeta_X: name is required").AsError();
-    const remote = await RemoteMetaStore(loader.sthis, dbName, metaUrl, {
+    if (!dbName) throw this.logger.Error().Url(metaUrl).Msg("connectMeta_X: dbName is required").AsError();
+    const gateway = rgateway.Ok();
+    const remote = await RemoteMetaStore(loader.sthis, name, metaUrl, {
       gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, loader.ebOpts.keyBag),
+      keybag: await loader.keyBag(),
       loader
     });
     this.loader.remoteMetaStore = remote;
@@ -3177,14 +3438,15 @@ var ConnectionBase = class {
   async connectStorage_X({ loader }) {
     if (!loader) throw this.logger.Error().Msg("connectStorage_X: loader is required").AsError();
     this.loader = loader;
-    const dataUrl = this.url.build().defParam("store", "data").URI();
-    const gateway = await getGatewayFromURL(dataUrl, this.loader.sthis);
-    if (!gateway) throw this.logger.Error().Url(dataUrl).Msg("connectStorage_X: gateway is required").AsError();
+    const dataUrl = this.url.build().defParam("store" /* STORE */, "data").URI();
+    const rgateway = await getStartedGateway(loader.sthis, dataUrl);
+    if (rgateway.isErr())
+      throw this.logger.Error().Result("err", rgateway).Url(dataUrl).Msg("connectStorage_X: gateway is required").AsError();
     const name = dataUrl.getParam("name");
     if (!name) throw this.logger.Error().Url(dataUrl).Msg("connectStorage_X: name is required").AsError;
     loader.remoteCarStore = await RemoteDataStore(loader.sthis, name, this.url, {
-      gateway: gateway.gateway,
-      keybag: () => getKeyBag(loader.sthis, this.loader?.ebOpts.keyBag)
+      gateway: rgateway.Ok().gateway,
+      keybag: await loader.keyBag()
     });
     loader.remoteFileStore = loader.remoteCarStore;
   }
@@ -3224,6 +3486,13 @@ var ConnectionBase = class {
 };
 
 // src/crdt-helpers.ts
+var import_link = require("multiformats/link");
+var import_sha25 = require("multiformats/hashes/sha2");
+var codec = __toESM(require("@ipld/dag-cbor"), 1);
+var import_crdt = require("@web3-storage/pail/crdt");
+var import_clock2 = require("@web3-storage/pail/clock");
+var Batch = __toESM(require("@web3-storage/pail/crdt/batch"), 1);
+init_types();
 function time(tag) {
 }
 function timeEnd(tag) {
@@ -3271,7 +3540,7 @@ async function writeDocContent(store, blocks, update, logger) {
     await processFiles(store, blocks, update.value, logger);
     value = { doc: update.value };
   }
-  const block = await encode({ value, hasher: import_sha25.sha256, codec });
+  const block = await encode3({ value, hasher: import_sha25.sha256, codec });
   blocks.putSync(block.cid, block.bytes);
   return block.cid;
 }
@@ -3362,7 +3631,7 @@ function readFileset(blocks, files, isPublic = false) {
 async function getValueFromLink(blocks, link, logger) {
   const block = await blocks.get(link);
   if (!block) throw logger.Error().Str("link", link.toString()).Msg(`Missing linked block`).AsError();
-  const { value } = await decode({ bytes: block.bytes, hasher: import_sha25.sha256, codec });
+  const { value } = await decode3({ bytes: block.bytes, hasher: import_sha25.sha256, codec });
   const cvalue = {
     ...value,
     cid: link
@@ -3483,16 +3752,19 @@ async function doCompact(blockLog, head, logger) {
 async function getBlock(blocks, cidString) {
   const block = await blocks.get((0, import_link.parse)(cidString));
   if (!block) throw new Error(`Missing block ${cidString}`);
-  const { cid, value } = await decode({ bytes: block.bytes, codec, hasher: import_sha25.sha256 });
+  const { cid, value } = await decode3({ bytes: block.bytes, codec, hasher: import_sha25.sha256 });
   return new Block({ cid, value, bytes: block.bytes });
 }
 
+// src/indexer.ts
+init_types();
+
 // src/indexer-helpers.ts
 var import_sha26 = require("multiformats/hashes/sha2");
 var codec2 = __toESM(require("@ipld/dag-cbor"), 1);
 var import_charwise = __toESM(require("charwise"), 1);
 var DbIndex = __toESM(require("prolly-trees/db-index"), 1);
-var import_utils16 = require("prolly-trees/utils");
+var import_utils15 = require("prolly-trees/utils");
 var import_cache = require("prolly-trees/cache");
 var IndexTree = class {
 };
@@ -3500,17 +3772,17 @@ function refCompare(aRef, bRef) {
   if (Number.isNaN(aRef)) return -1;
   if (Number.isNaN(bRef)) throw new Error("ref may not be Infinity or NaN");
   if (aRef === Infinity) return 1;
-  return (0, import_utils16.simpleCompare)(aRef, bRef);
+  return (0, import_utils15.simpleCompare)(aRef, bRef);
 }
 function compare(a, b) {
   const [aKey, aRef] = a;
   const [bKey, bRef] = b;
-  const comp = (0, import_utils16.simpleCompare)(aKey, bKey);
+  const comp = (0, import_utils15.simpleCompare)(aKey, bKey);
   if (comp !== 0) return comp;
   return refCompare(aRef, bRef);
 }
-var byKeyOpts = { cache: import_cache.nocache, chunker: (0, import_utils16.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare };
-var byIdOpts = { cache: import_cache.nocache, chunker: (0, import_utils16.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare: import_utils16.simpleCompare };
+var byKeyOpts = { cache: import_cache.nocache, chunker: (0, import_utils15.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare };
+var byIdOpts = { cache: import_cache.nocache, chunker: (0, import_utils15.bf)(30), codec: codec2, hasher: import_sha26.sha256, compare: import_utils15.simpleCompare };
 function indexEntriesForChanges(changes, mapFn) {
   const indexEntries = [];
   changes.forEach(({ id: key, value, del }) => {
@@ -3541,7 +3813,8 @@ function makeProllyGetBlock(blocks) {
     return create({ cid, bytes, hasher: import_sha26.sha256, codec: codec2 });
   };
 }
-async function bulkIndex(tblocks, inIndex, indexEntries, opts) {
+async function bulkIndex(logger, tblocks, inIndex, indexEntries, opts) {
+  logger.Debug().Msg("enter bulkIndex");
   if (!indexEntries.length) return inIndex;
   if (!inIndex.root) {
     if (!inIndex.cid) {
@@ -3558,18 +3831,22 @@ async function bulkIndex(tblocks, inIndex, indexEntries, opts) {
         returnNode = node;
       }
       if (!returnNode || !returnRootBlock) throw new Error("failed to create index");
+      logger.Debug().Msg("exit !root bulkIndex");
       return { root: returnNode, cid: returnRootBlock.cid };
     } else {
       inIndex.root = await DbIndex.load({ cid: inIndex.cid, get: makeProllyGetBlock(tblocks), ...opts });
     }
   }
+  logger.Debug().Msg("pre bulk bulkIndex");
   const { root: root3, blocks: newBlocks } = await inIndex.root.bulk(indexEntries);
   if (root3) {
+    logger.Debug().Msg("pre root put bulkIndex");
     for await (const block of newBlocks) {
       await tblocks.put(block.cid, block.bytes);
     }
     return { root: root3, cid: (await root3.block).cid };
   } else {
+    logger.Debug().Msg("pre !root bulkIndex");
     return { root: void 0, cid: void 0 };
   }
 }
@@ -3610,17 +3887,17 @@ function encodeKey(key) {
 
 // src/indexer.ts
 init_utils();
-function index(sthis, { _crdt }, name, mapFn, meta) {
-  if (mapFn && meta) throw _crdt.logger.Error().Msg("cannot provide both mapFn and meta").AsError();
-  if (mapFn && mapFn.constructor.name !== "Function") throw _crdt.logger.Error().Msg("mapFn must be a function").AsError();
-  if (_crdt.indexers.has(name)) {
-    const idx = _crdt.indexers.get(name);
+function index(refDb, name, mapFn, meta) {
+  if (mapFn && meta) throw refDb.crdt.logger.Error().Msg("cannot provide both mapFn and meta").AsError();
+  if (mapFn && mapFn.constructor.name !== "Function") throw refDb.crdt.logger.Error().Msg("mapFn must be a function").AsError();
+  if (refDb.crdt.indexers.has(name)) {
+    const idx = refDb.crdt.indexers.get(name);
     idx.applyMapFn(name, mapFn, meta);
   } else {
-    const idx = new Index(sthis, _crdt, name, mapFn, meta);
-    _crdt.indexers.set(name, idx);
+    const idx = new Index(refDb.crdt.sthis, refDb.crdt, name, mapFn, meta);
+    refDb.crdt.indexers.set(name, idx);
   }
-  return _crdt.indexers.get(name);
+  return refDb.crdt.indexers.get(name);
 }
 var Index = class {
   constructor(sthis, crdt, name, mapFn, meta) {
@@ -3639,18 +3916,9 @@ var Index = class {
     return Promise.all([this.blockstore.ready(), this.crdt.ready()]).then(() => {
     });
   }
-  close() {
-    return Promise.all([this.blockstore.close(), this.crdt.close()]).then(() => {
-    });
-  }
-  destroy() {
-    return Promise.all([this.blockstore.destroy(), this.crdt.destroy()]).then(() => {
-    });
-  }
   applyMapFn(name, mapFn, meta) {
     if (mapFn && meta) throw this.logger.Error().Msg("cannot provide both mapFn and meta").AsError();
     if (this.name && this.name !== name) throw this.logger.Error().Msg("cannot change name").AsError();
-    this.name = name;
     try {
       if (meta) {
         if (this.indexHead && this.indexHead.map((c) => c.toString()).join() !== meta.head.map((c) => c.toString()).join()) {
@@ -3698,9 +3966,13 @@ var Index = class {
     }
   }
   async query(opts = {}) {
+    this.logger.Debug().Msg("enter query");
     await this.ready();
+    this.logger.Debug().Msg("post ready query");
     await this._updateIndex();
+    this.logger.Debug().Msg("post _updateIndex query");
     await this._hydrateIndex();
+    this.logger.Debug().Msg("post _hydrateIndex query");
     if (!this.byKey.root) {
       return await applyQuery(this.crdt, { result: [] }, opts);
     }
@@ -3756,13 +4028,16 @@ var Index = class {
   }
   async _updateIndex() {
     await this.ready();
+    this.logger.Debug().Msg("enter _updateIndex");
     if (this.initError) throw this.initError;
     if (!this.mapFn) throw this.logger.Error().Msg("No map function defined").AsError();
     let result, head;
     if (!this.indexHead || this.indexHead.length === 0) {
       ({ result, head } = await this.crdt.allDocs());
+      this.logger.Debug().Msg("enter crdt.allDocs");
     } else {
       ({ result, head } = await this.crdt.changes(this.indexHead));
+      this.logger.Debug().Msg("enter crdt.changes");
     }
     if (result.length === 0) {
       this.indexHead = head;
@@ -3795,9 +4070,22 @@ var Index = class {
     if (result.length === 0) {
       return indexerMeta;
     }
+    this.logger.Debug().Msg("pre this.blockstore.transaction");
     const { meta } = await this.blockstore.transaction(async (tblocks) => {
-      this.byId = await bulkIndex(tblocks, this.byId, removeIdIndexEntries.concat(byIdIndexEntries), byIdOpts);
-      this.byKey = await bulkIndex(tblocks, this.byKey, staleKeyIndexEntries.concat(indexEntries), byKeyOpts);
+      this.byId = await bulkIndex(
+        this.logger,
+        tblocks,
+        this.byId,
+        removeIdIndexEntries.concat(byIdIndexEntries),
+        byIdOpts
+      );
+      this.byKey = await bulkIndex(
+        this.logger,
+        tblocks,
+        this.byKey,
+        staleKeyIndexEntries.concat(indexEntries),
+        byKeyOpts
+      );
       this.indexHead = head;
       if (this.byId.cid && this.byKey.cid) {
         const idxMeta = {
@@ -3809,8 +4097,10 @@ var Index = class {
         };
         indexerMeta.indexes?.set(this.name, idxMeta);
       }
+      this.logger.Debug().Any("indexerMeta", new Array(indexerMeta.indexes?.entries())).Msg("exit this.blockstore.transaction fn");
       return indexerMeta;
     });
+    this.logger.Debug().Msg("post this.blockstore.transaction");
     return meta;
   }
 };
@@ -3818,7 +4108,8 @@ var Index = class {
 // src/crdt-clock.ts
 var import_clock3 = require("@web3-storage/pail/clock");
 var import_crdt2 = require("@web3-storage/pail/crdt");
-var import_cement14 = require("@adviser/cement");
+var import_cement16 = require("@adviser/cement");
+init_types();
 
 // src/apply-head-queue.ts
 function applyHeadQueue(worker, logger) {
@@ -3876,7 +4167,7 @@ var CRDTClock = class {
     this.zoomers = /* @__PURE__ */ new Set();
     this.watchers = /* @__PURE__ */ new Set();
     this.emptyWatchers = /* @__PURE__ */ new Set();
-    this._ready = new import_cement14.ResolveOnce();
+    this._ready = new import_cement16.ResolveOnce();
     this.blockstore = blockstore;
     this.logger = ensureLogger(blockstore.sthis, "CRDTClock");
     this.applyHeadQueue = applyHeadQueue(this.int_applyHead.bind(this), this.logger);
@@ -3939,21 +4230,23 @@ var CRDTClock = class {
       throw this.logger.Error().Msg("missing blockstore").AsError();
     }
     await validateBlocks(this.logger, newHead, this.blockstore);
-    const { meta } = await this.blockstore.transaction(
-      async (tblocks) => {
-        const advancedHead = await advanceBlocks(this.logger, newHead, tblocks, this.head);
-        const result = await (0, import_crdt2.root)(tblocks, advancedHead);
-        for (const { cid, bytes } of [
-          ...result.additions
-          // ...result.removals
-        ]) {
-          tblocks.putSync(cid, bytes);
-        }
-        return { head: advancedHead };
-      },
-      { noLoader, add: false }
-    );
-    this.setHead(meta.head);
+    if (!this.transaction) {
+      this.transaction = this.blockstore.openTransaction({ noLoader, add: false });
+    }
+    const tblocks = this.transaction;
+    const advancedHead = await advanceBlocks(this.logger, newHead, tblocks, this.head);
+    const result = await (0, import_crdt2.root)(tblocks, advancedHead);
+    for (const { cid, bytes } of [
+      ...result.additions
+      // ...result.removals
+    ]) {
+      tblocks.putSync(cid, bytes);
+    }
+    if (!noLoader) {
+      await this.blockstore.commitTransaction(tblocks, { head: advancedHead }, { add: false, noLoader });
+      this.transaction = void 0;
+    }
+    this.setHead(advancedHead);
   }
 };
 function sortClockHead(clockHead) {
@@ -3986,15 +4279,13 @@ async function advanceBlocks(logger, newHead, tblocks, head) {
 // src/crdt.ts
 init_utils();
 var CRDT = class {
-  constructor(sthis, name, opts = {}) {
+  constructor(sthis, opts) {
     this.indexers = /* @__PURE__ */ new Map();
-    this.onceReady = new import_cement15.ResolveOnce();
+    this.onceReady = new import_cement17.ResolveOnce();
     this.sthis = sthis;
-    this.name = name;
     this.logger = ensureLogger(sthis, "CRDT");
     this.opts = opts;
     this.blockstore = blockstoreFactory(sthis, {
-      name,
       applyMeta: async (meta) => {
         const crdtMeta = meta;
         if (!crdtMeta.head) throw this.logger.Error().Msg("missing head").AsError();
@@ -4004,23 +4295,27 @@ var CRDT = class {
         await doCompact(blocks, this.clock.head, this.logger);
         return { head: this.clock.head };
       },
-      autoCompact: this.opts.autoCompact || 100,
-      store: { ...this.opts.store, isIndex: void 0 },
-      public: this.opts.public,
-      meta: this.opts.meta,
-      threshold: this.opts.threshold
+      // autoCompact: this.opts.autoCompact || 100,
+      storeRuntime: toStoreRuntime(this.sthis, this.opts.storeEnDe),
+      storeUrls: this.opts.storeUrls.data,
+      keyBag: this.opts.keyBag,
+      // public: this.opts.public,
+      meta: this.opts.meta
+      // threshold: this.opts.threshold,
     });
     this.indexBlockstore = blockstoreFactory(sthis, {
-      name,
+      // name: opts.name,
       applyMeta: async (meta) => {
         const idxCarMeta = meta;
         if (!idxCarMeta.indexes) throw this.logger.Error().Msg("missing indexes").AsError();
-        for (const [name2, idx] of Object.entries(idxCarMeta.indexes)) {
-          index(this.sthis, { _crdt: this }, name2, void 0, idx);
+        for (const [name, idx] of Object.entries(idxCarMeta.indexes)) {
+          index({ crdt: this }, name, void 0, idx);
         }
       },
-      store: { ...this.opts.store, isIndex: this.opts.store?.isIndex || "idx" },
-      public: this.opts.public
+      storeRuntime: toStoreRuntime(this.sthis, this.opts.storeEnDe),
+      storeUrls: this.opts.storeUrls.idx,
+      keyBag: this.opts.keyBag
+      // public: this.opts.public,
     });
     this.clock = new CRDTClock(this.blockstore);
     this.clock.onZoom(() => {
@@ -4102,52 +4397,166 @@ var CRDT = class {
 };
 
 // src/database.ts
+init_types();
 init_utils();
-var Database = class {
-  constructor(name, opts) {
-    this.opts = {};
+var databases = new import_cement18.KeyedResolvOnce();
+function toSortedArray(set) {
+  if (!set) return [];
+  return Object.entries(set).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => ({ [k]: v }));
+}
+function keyConfigOpts(sthis, name, opts) {
+  return JSON.stringify(
+    toSortedArray({
+      name,
+      stores: toSortedArray(JSON.parse(JSON.stringify(toStoreURIRuntime(sthis, name, opts?.storeUrls))))
+    })
+  );
+}
+function isDatabase(db) {
+  return db instanceof DatabaseImpl || db instanceof DatabaseShell;
+}
+function DatabaseFactory(name, opts) {
+  const sthis = ensureSuperThis(opts);
+  return new DatabaseShell(
+    databases.get(keyConfigOpts(sthis, name, opts)).once((key) => {
+      const db = new DatabaseImpl(sthis, {
+        name,
+        meta: opts?.meta,
+        keyBag: defaultKeyBagOpts(sthis, opts?.keyBag),
+        storeUrls: toStoreURIRuntime(sthis, name, opts?.storeUrls),
+        storeEnDe: {
+          encodeFile,
+          decodeFile,
+          ...opts?.storeEnDe
+        }
+      });
+      db.onClosed(() => {
+        databases.unget(key);
+      });
+      return db;
+    })
+  );
+}
+var DatabaseShell = class {
+  constructor(ref) {
+    this.ref = ref;
+    ref.addShell(this);
+  }
+  get id() {
+    return this.ref.id;
+  }
+  get logger() {
+    return this.ref.logger;
+  }
+  get sthis() {
+    return this.ref.sthis;
+  }
+  get crdt() {
+    return this.ref.crdt;
+  }
+  name() {
+    return this.ref.name();
+  }
+  onClosed(fn) {
+    return this.ref.onClosed(fn);
+  }
+  close() {
+    return this.ref.shellClose(this);
+  }
+  destroy() {
+    return this.ref.destroy();
+  }
+  ready() {
+    return this.ref.ready();
+  }
+  get(id) {
+    return this.ref.get(id);
+  }
+  put(doc) {
+    return this.ref.put(doc);
+  }
+  del(id) {
+    return this.ref.del(id);
+  }
+  changes(since, opts) {
+    return this.ref.changes(since, opts);
+  }
+  allDocs(opts) {
+    return this.ref.allDocs(opts);
+  }
+  allDocuments() {
+    return this.ref.allDocuments();
+  }
+  subscribe(listener, updates) {
+    return this.ref.subscribe(listener, updates);
+  }
+  query(field, opts) {
+    return this.ref.query(field, opts);
+  }
+  compact() {
+    return this.ref.compact();
+  }
+};
+var DatabaseImpl = class {
+  constructor(sthis, opts) {
     this._listening = false;
     this._listeners = /* @__PURE__ */ new Set();
     this._noupdate_listeners = /* @__PURE__ */ new Set();
-    this._ready = new import_cement16.ResolveOnce();
-    this.name = name;
-    this.opts = opts || this.opts;
-    this.sthis = ensureSuperThis(this.opts);
+    // readonly blockstore: BaseBlockstore;
+    this.shells = /* @__PURE__ */ new Set();
+    this._onClosedFns = /* @__PURE__ */ new Set();
+    this._ready = new import_cement18.ResolveOnce();
+    this.opts = opts;
+    this.sthis = sthis;
+    this.id = sthis.timeOrderedNextId().str;
     this.logger = ensureLogger(this.sthis, "Database");
-    this._crdt = new CRDT(this.sthis, name, this.opts);
-    this.blockstore = this._crdt.blockstore;
+    this.crdt = new CRDT(this.sthis, this.opts);
     this._writeQueue = writeQueue(async (updates) => {
-      return await this._crdt.bulk(updates);
+      return await this.crdt.bulk(updates);
     });
-    this._crdt.clock.onTock(() => {
+    this.crdt.clock.onTock(() => {
       this._no_update_notify();
     });
   }
-  static {
-    this.databases = /* @__PURE__ */ new Map();
+  addShell(shell) {
+    this.shells.add(shell);
+  }
+  onClosed(fn) {
+    this._onClosedFns.add(fn);
   }
   async close() {
-    await this.ready();
-    await this._crdt.close();
-    await this.blockstore.close();
+    throw this.logger.Error().Str("db", this.name()).Msg(`use shellClose`).AsError();
+  }
+  async shellClose(db) {
+    if (!this.shells.has(db)) {
+      throw this.logger.Error().Str("db", this.name()).Msg(`Database Shell mismatch`).AsError();
+    }
+    this.shells.delete(db);
+    if (this.shells.size === 0) {
+      await this.ready();
+      await this.crdt.close();
+      this._onClosedFns.forEach((fn) => fn());
+    }
   }
   async destroy() {
     await this.ready();
-    await this._crdt.destroy();
-    await this.blockstore.destroy();
+    await this.crdt.destroy();
   }
   async ready() {
-    return this._ready.once(async () => {
+    const ret = await this._ready.once(async () => {
       await this.sthis.start();
-      await this._crdt.ready();
-      await this.blockstore.ready();
+      await this.crdt.ready();
     });
+    return ret;
+  }
+  name() {
+    return this.opts.storeUrls.data.data.getParam("name" /* NAME */) || "default";
   }
   async get(id) {
-    if (!id) throw this.logger.Error().Str("db", this.name).Msg(`Doc id is required`).AsError();
+    if (!id) throw this.logger.Error().Str("db", this.name()).Msg(`Doc id is required`).AsError();
     await this.ready();
     this.logger.Debug().Str("id", id).Msg("get");
-    const got = await this._crdt.get(id).catch((e) => {
+    const got = await this.crdt.get(id).catch((e) => {
       throw new NotFoundError(`Not found: ${id} - ${e.message}`);
     });
     if (!got) throw new NotFoundError(`Not found: ${id}`);
@@ -4166,34 +4575,34 @@ var Database = class {
         _id: docId
       }
     });
-    return { id: docId, clock: result?.head, name: this.name };
+    return { id: docId, clock: result?.head, name: this.name() };
   }
   async del(id) {
     await this.ready();
     this.logger.Debug().Str("id", id).Msg("del");
     const result = await this._writeQueue.push({ id, del: true });
-    return { id, clock: result?.head, name: this.name };
+    return { id, clock: result?.head, name: this.name() };
   }
   async changes(since = [], opts = {}) {
     await this.ready();
     this.logger.Debug().Any("since", since).Any("opts", opts).Msg("changes");
-    const { result, head } = await this._crdt.changes(since, opts);
+    const { result, head } = await this.crdt.changes(since, opts);
     const rows = result.map(({ id: key, value, del, clock }) => ({
       key,
       value: del ? { _id: key, _deleted: true } : { _id: key, ...value },
       clock
     }));
-    return { rows, clock: head, name: this.name };
+    return { rows, clock: head, name: this.name() };
   }
   async allDocs(opts = {}) {
     await this.ready();
     this.logger.Debug().Msg("allDocs");
-    const { result, head } = await this._crdt.allDocs();
+    const { result, head } = await this.crdt.allDocs();
     const rows = result.map(({ id: key, value, del }) => ({
       key,
       value: del ? { _id: key, _deleted: true } : { _id: key, ...value }
     }));
-    return { rows, clock: head, name: this.name };
+    return { rows, clock: head, name: this.name() };
   }
   async allDocuments() {
     return this.allDocs();
@@ -4203,7 +4612,7 @@ var Database = class {
     if (updates) {
       if (!this._listening) {
         this._listening = true;
-        this._crdt.clock.onTick((updates2) => {
+        this.crdt.clock.onTick((updates2) => {
           void this._notify(updates2);
         });
       }
@@ -4222,13 +4631,13 @@ var Database = class {
   async query(field, opts = {}) {
     await this.ready();
     this.logger.Debug().Any("field", field).Any("opts", opts).Msg("query");
-    const _crdt = this._crdt;
-    const idx = typeof field === "string" ? index(this.sthis, { _crdt }, field) : index(this.sthis, { _crdt }, makeName(field.toString()), field);
+    const _crdt = this.crdt;
+    const idx = typeof field === "string" ? index({ crdt: _crdt }, field) : index({ crdt: _crdt }, makeName(field.toString()), field);
     return await idx.query(opts);
   }
   async compact() {
     await this.ready();
-    await this._crdt.compact();
+    await this.crdt.compact();
   }
   async _notify(updates) {
     await this.ready();
@@ -4252,23 +4661,62 @@ var Database = class {
     }
   }
 };
-function toSortedArray(set) {
-  if (!set) return [];
-  return Object.entries(set).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => ({ [k]: v }));
+function defaultURI(sthis, curi, uri, store, ctx) {
+  ctx = ctx || {};
+  const ret = (curi ? import_cement18.URI.from(curi) : uri).build().setParam("store" /* STORE */, store);
+  if (!ret.hasParam("name" /* NAME */)) {
+    const name = sthis.pathOps.basename(ret.URI().pathname);
+    if (!name) {
+      throw sthis.logger.Error().Url(ret).Any("ctx", ctx).Msg("Database name is required").AsError();
+    }
+    ret.setParam("name" /* NAME */, name);
+  }
+  if (ctx.idx) {
+    ret.defParam("index" /* INDEX */, "idx");
+    ret.defParam("storekey" /* STORE_KEY */, `@${ret.getParam("name" /* NAME */)}-${store}-idx@`);
+  } else {
+    ret.defParam("storekey" /* STORE_KEY */, `@${ret.getParam("name" /* NAME */)}-${store}@`);
+  }
+  if (store === "data") {
+    if (ctx.file) {
+    } else {
+      ret.defParam("suffix" /* SUFFIX */, ".car");
+    }
+  }
+  return ret.URI();
 }
-function fireproof(name, opts) {
-  const key = JSON.stringify(
-    toSortedArray({
-      name,
-      stores: toSortedArray(opts?.store?.stores)
-    })
-  );
-  let db = Database.databases.get(key);
-  if (!db) {
-    db = new Database(name, opts);
-    Database.databases.set(key, db);
+function toStoreURIRuntime(sthis, name, sopts) {
+  sopts = sopts || {};
+  if (!sopts.base) {
+    const fp_env = sthis.env.get("FP_STORAGE_URL");
+    if (fp_env) {
+      sopts = { ...sopts, base: import_cement18.BuildURI.from(fp_env).setParam("urlGen" /* URL_GEN */, "fromEnv") };
+    } else {
+      sopts = { ...sopts, base: getDefaultURI(sthis).build().setParam("urlGen" /* URL_GEN */, "default") };
+    }
+  }
+  const bbase = import_cement18.BuildURI.from(sopts.base);
+  if (name) {
+    bbase.setParam("name" /* NAME */, name);
   }
-  return db;
+  const base = bbase.URI();
+  return {
+    idx: {
+      data: defaultURI(sthis, sopts.idx?.data, base, "data", { idx: true }),
+      file: defaultURI(sthis, sopts.idx?.data, base, "data", { file: true, idx: true }),
+      meta: defaultURI(sthis, sopts.idx?.meta, base, "meta", { idx: true }),
+      wal: defaultURI(sthis, sopts.idx?.wal, base, "wal", { idx: true })
+    },
+    data: {
+      data: defaultURI(sthis, sopts.data?.data, base, "data"),
+      file: defaultURI(sthis, sopts.data?.data, base, "data", { file: true }),
+      meta: defaultURI(sthis, sopts.data?.meta, base, "meta"),
+      wal: defaultURI(sthis, sopts.data?.wal, base, "wal")
+    }
+  };
+}
+function fireproof(name, opts) {
+  return DatabaseFactory(name, opts);
 }
 function makeName(fnString) {
   const regex = /\(([^,()]+,\s*[^,()]+|\[[^\]]+\],\s*[^,()]+)\)/g;
@@ -4287,6 +4735,9 @@ function makeName(fnString) {
   }
 }
 
+// src/index.ts
+init_types();
+
 // src/runtime/index.ts
 var runtime_exports = {};
 __export(runtime_exports, {
@@ -4299,7 +4750,7 @@ __export(runtime_exports, {
   kb: () => key_bag_exports,
   kc: () => keyed_crypto_exports,
   mf: () => wait_pr_multiformats_exports,
-  runtimeFn: () => import_cement17.runtimeFn,
+  runtimeFn: () => import_cement19.runtimeFn,
   toArrayBuffer: () => toArrayBuffer
 });
 init_utils2();
@@ -4315,7 +4766,7 @@ __export(wait_pr_multiformats_exports, {
 var codec_interface_exports = {};
 
 // src/runtime/index.ts
-var import_cement17 = require("@adviser/cement");
+var import_cement19 = require("@adviser/cement");
 init_version();
 init_version2();
 
@@ -4324,6 +4775,6 @@ init_utils();
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.99": "xxxx"
+  "0.19.101": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map