@fireproof/core 0.19.8-dev-global → 0.19.9-dev-frag

package/index.cjs

@@ -30,452 +30,50 @@ 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 init_types = __esm({
-  "src/types.ts"() {
-    "use strict";
-  }
-});
-
-// src/runtime/node-sys-container.ts
-var node_sys_container_exports = {};
-__export(node_sys_container_exports, {
-  createNodeSysContainer: () => createNodeSysContainer
-});
-async function createNodeSysContainer() {
-  return {
-    state: "node",
-    ...path,
-    // ...(await import("node:os")),
-    // ...(await import("node:url")),
-    ...os,
-    ...url,
-    ...fs,
-    join,
-    stat: fs.stat,
-    readdir: fs.readdir,
-    readfile: fs.readFile,
-    writefile: fs.writeFile
-  };
-}
-var fs, path, os, url;
-var init_node_sys_container = __esm({
-  "src/runtime/node-sys-container.ts"() {
-    "use strict";
-    init_sys_container();
-    fs = __toESM(require("fs/promises"), 1);
-    path = __toESM(require("path"), 1);
-    os = __toESM(require("os"), 1);
-    url = __toESM(require("url"), 1);
-  }
-});
-
-// src/runtime/sys-container.ts
-function isSet(value, ref = globalThis) {
-  const [head, ...tail] = value.split(".");
-  if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
-    if (tail.length <= 1) {
-      return true;
-    }
-    return isSet(tail.join("."), ref[head]);
-  }
-  return false;
-}
-function runtimeFn() {
-  const isNodeIsh = isSet("process.versions.node");
-  const isDeno = isSet("Deno");
-  return {
-    isNodeIsh,
-    isBrowser: !(isNodeIsh || isDeno),
-    isDeno,
-    isReactNative: false
-  };
-}
-function join(...paths) {
-  return paths.map((i) => i.replace(/\/+$/, "")).join("/");
-}
-var import_uuidv7, import_cement, onceStart, envImpl, sysContainer, SysContainer;
-var init_sys_container = __esm({
-  "src/runtime/sys-container.ts"() {
-    "use strict";
-    import_uuidv7 = require("uuidv7");
-    import_cement = require("@adviser/cement");
-    init_types();
-    onceStart = new import_cement.ResolveOnce();
-    envImpl = new import_cement.EnvImpl({
-      symbol: "FP_ENV",
-      presetEnv: /* @__PURE__ */ new Map([
-        // ["FP_DEBUG", "xxx"],
-        // ["FP_ENV", "development"],
-      ])
-    });
-    sysContainer = class {
-      constructor() {
-        this.freight = {
-          state: "seeded",
-          join,
-          dirname: (path2) => path2.split("/").slice(0, -1).join("/"),
-          homedir: () => {
-            throw new Error("SysContainer:homedir is not available in seeded state");
-          },
-          fileURLToPath: (strurl) => {
-            let url2;
-            if (typeof strurl === "string") {
-              url2 = new URL(strurl);
-            } else {
-              url2 = strurl;
-            }
-            return url2.pathname;
-          },
-          // assert: (condition: unknown, message?: string | Error) => {
-          //   if (!condition) {
-          //     if (message instanceof Error) {
-          //       throw message;
-          //     } else {
-          //       throw new Error(message);
-          //     }
-          //   }
-          // },
-          mkdir: () => Promise.reject(new Error("SysContainer:mkdir is not available in seeded state")),
-          readdir: () => Promise.reject(new Error("SysContainer:readdir is not available in seeded state")),
-          rm: () => Promise.reject(new Error("SysContainer:rm is not available in seeded state")),
-          copyFile: () => Promise.reject(new Error("SysContainer:copyFile is not available in seeded state")),
-          readfile: () => Promise.reject(new Error("SysContainer:readfile is not available in seeded state")),
-          unlink: () => Promise.reject(new Error("SysContainer:unlink is not available in seeded state")),
-          writefile: () => Promise.reject(new Error("SysContainer:writefile is not available in seeded state")),
-          stat: () => Promise.reject(new Error("SysContainer:stat is not available in seeded state"))
-        };
-        this.id = (0, import_uuidv7.uuidv4)();
-        this.homedir = () => {
-          this.logSeeded("homedir");
-          return throwFalsy(this.freight).homedir();
-        };
-        this.runtime = runtimeFn;
-        this.env = envImpl;
-      }
-      async start() {
-        await onceStart.once(async () => {
-          switch (this.freight.state) {
-            case "seeded":
-              if (this.runtime().isNodeIsh) {
-                const { createNodeSysContainer: createNodeSysContainer2 } = await Promise.resolve().then(() => (init_node_sys_container(), node_sys_container_exports));
-                this.freight = await createNodeSysContainer2();
-              } else {
-                this.freight.state = "browser";
-              }
-              return;
-            case "browser":
-            case "node":
-              return;
-          }
-        });
-      }
-      async readdir(path2, options) {
-        this.logSeeded("readdir");
-        return throwFalsy(this.freight).readdir(path2, options) || [];
-      }
-      async readdirent(path2, options) {
-        this.logSeeded("readdirent");
-        return throwFalsy(this.freight).readdir(path2, { ...options, withFileTypes: true }) || [];
-      }
-      async readfile(path2, options) {
-        this.logSeeded("readfile");
-        return throwFalsy(this.freight).readfile(path2, options);
-      }
-      async mkdir(path2, options) {
-        this.logSeeded("mkdir");
-        return throwFalsy(this.freight).mkdir(path2, options);
-      }
-      async rm(path2, options) {
-        this.logSeeded("rm");
-        return throwFalsy(this.freight).rm(path2, options);
-      }
-      async unlink(path2) {
-        this.logSeeded("unlink");
-        return throwFalsy(this.freight).unlink(path2);
-      }
-      async writefile(path2, data) {
-        this.logSeeded("writefile");
-        return throwFalsy(this.freight).writefile(path2, data);
-      }
-      async copyFile(source, destination) {
-        this.logSeeded("copyFile");
-        return throwFalsy(this.freight).copyFile(source, destination);
-      }
-      async stat(path2) {
-        this.logSeeded("stat");
-        return throwFalsy(this.freight).stat(path2);
-      }
-      fileURLToPath(url2) {
-        this.logSeeded("fileURLToPath");
-        return throwFalsy(this.freight).fileURLToPath(url2);
-      }
-      dirname(path2) {
-        this.logSeeded("dirname");
-        return throwFalsy(this.freight).dirname(path2);
-      }
-      join(...args) {
-        this.logSeeded("join");
-        return throwFalsy(this.freight).join(...args);
-      }
-      logSeeded(method) {
-        if (this.freight.state === "seeded") {
-          const err = new Error();
-          console.warn(`SysContainer.${method} is not available in seeded state:`, err.stack);
-        }
-      }
-    };
-    SysContainer = new sysContainer();
-  }
-});
-
-// src/runtime/data-dir.ts
-function dataDir(name, base) {
-  if (!base) {
-    if (SysContainer.runtime().isNodeIsh || SysContainer.runtime().isDeno) {
-      base = SysContainer.env.get("FP_STORAGE_URL") || `file://${SysContainer.join(SysContainer.homedir(), ".fireproof")}`;
-    } else {
-      base = `indexdb://fp`;
-    }
-  }
-  let url2;
-  if (typeof base === "string") {
-    try {
-      url2 = new URL(base.toString());
-    } catch (e) {
-      try {
-        base = `file://${base}`;
-        url2 = new URL(base);
-      } catch (e2) {
-        throw new Error(`invalid base url: ${base}`);
-      }
-    }
-  } else {
-    url2 = base;
-  }
-  url2.searchParams.set("name", name || "");
-  return url2.toString();
-}
-var init_data_dir = __esm({
-  "src/runtime/data-dir.ts"() {
-    "use strict";
-    init_sys_container();
-  }
-});
-
-// src/runtime/store-file-utils.ts
-async function getPath(url2, logger) {
-  const basePath = url2.toString().replace(new RegExp(`^${url2.protocol}//`), "").replace(/\?.*$/, "");
-  const name = url2.searchParams.get("name");
-  if (name) {
-    const version = url2.searchParams.get("version");
-    if (!version) throw logger.Error().Str("url", url2.toString()).Msg(`version not found`).AsError();
-    return SysContainer.join(basePath, version, name);
-  }
-  return SysContainer.join(basePath);
-}
-function getFileName(url2, key, logger) {
-  switch (getStore(url2, logger, (...a) => a.join("/"))) {
-    case "data":
-      return key + ".car";
-    case "meta":
-      return key + ".json";
-    default:
-      throw logger.Error().Str("url", url2.toString()).Msg(`unsupported store type`).AsError();
-  }
-}
-function ensureIndexName(url2, name) {
-  if (url2.searchParams.has("index")) {
-    name = (url2.searchParams.get("index")?.replace(/[^a-zA-Z0-9]/g, "") || "idx") + "-" + name;
-  }
-  return name;
-}
-var init_store_file_utils = __esm({
-  "src/runtime/store-file-utils.ts"() {
-    "use strict";
-    init_utils();
-    init_sys_container();
-  }
-});
-
-// src/runtime/crypto.ts
-var crypto_exports = {};
-__export(crypto_exports, {
-  toCryptoOpts: () => toCryptoOpts
-});
-function randomBytes(size) {
-  const bytes = new Uint8Array(size);
-  if (size > 0) {
-    crypto.getRandomValues(bytes);
-  }
-  return bytes;
-}
-function digestSHA256(data) {
-  return Promise.resolve(crypto.subtle.digest("SHA-256", data));
-}
-function toCryptoOpts(cryptoOpts = {}) {
-  const opts = {
-    importKey: cryptoOpts.importKey || crypto.subtle.importKey.bind(crypto.subtle),
-    encrypt: cryptoOpts.encrypt || crypto.subtle.encrypt.bind(crypto.subtle),
-    decrypt: cryptoOpts.decrypt || crypto.subtle.decrypt.bind(crypto.subtle),
-    randomBytes: cryptoOpts.randomBytes || randomBytes,
-    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256
-  };
-  return opts;
-}
-var init_crypto = __esm({
-  "src/runtime/crypto.ts"() {
-    "use strict";
-  }
-});
-
-// src/runtime/files.ts
-var files_exports = {};
-__export(files_exports, {
-  decodeFile: () => decodeFile,
-  encodeFile: () => encodeFile
-});
-async function collect(collectable) {
-  const chunks = [];
-  await collectable.pipeTo(
-    new WritableStream({
-      write(chunk) {
-        chunks.push(chunk);
-      }
-    })
-  );
-  return chunks;
-}
-async function encodeFile(blob) {
-  const readable = createFileEncoderStream(blob);
-  const blocks = await collect(readable);
-  return { cid: blocks.at(-1).cid, blocks };
+// src/utils.ts
+function presetEnv() {
+  const penv = new Map([
+    // ["FP_DEBUG", "xxx"],
+    // ["FP_ENV", "development"],
+    ...Array.from(
+      Object.entries(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        globalThis[Symbol.for("FP_PRESET_ENV")] || {}
+      )
+    )
+    // .map(([k, v]) => [k, v as string])
+  ]);
+  return penv;
 }
-async function decodeFile(blocks, cid, meta) {
-  const entry = await (0, import_ipfs_unixfs_exporter.exporter)(cid.toString(), blocks, { length: meta.size });
-  const chunks = [];
-  for await (const chunk of entry.content()) {
-    chunks.push(chunk);
-  }
-  return new File(chunks, entry.name, { type: meta.type, lastModified: 0 });
+function ensureSuperThis(osthis) {
+  const env = (0, import_cement.envFactory)({
+    symbol: osthis?.env?.symbol || "FP_ENV",
+    presetEnv: osthis?.env?.presetEnv || presetEnv()
+  });
+  return new superThis({
+    logger: osthis?.logger || globalLogger,
+    env,
+    crypto: osthis?.crypto || (0, import_cement.toCryptoRuntime)(),
+    ctx: osthis?.ctx || {},
+    pathOps,
+    txt: osthis?.txt || txtOps
+  });
 }
-function createFileEncoderStream(blob) {
-  const { readable, writable } = new TransformStream({}, queuingStrategy);
-  const unixfsWriter = UnixFS.createWriter({ writable, settings });
-  const fileBuilder = new UnixFSFileBuilder("", blob);
-  void (async () => {
-    await fileBuilder.finalize(unixfsWriter);
-    await unixfsWriter.close();
-  })();
-  return readable;
+function ensureSuperLog(sthis, componentName, ctx) {
+  return sthis.clone({
+    logger: ensureLogger(sthis, componentName, ctx)
+  });
 }
-var UnixFS, raw, import_fixed, import_balanced, import_ipfs_unixfs_exporter, queuingStrategy, settings, UnixFSFileBuilder;
-var init_files = __esm({
-  "src/runtime/files.ts"() {
-    "use strict";
-    UnixFS = __toESM(require("@ipld/unixfs"), 1);
-    raw = __toESM(require("multiformats/codecs/raw"), 1);
-    import_fixed = require("@ipld/unixfs/file/chunker/fixed");
-    import_balanced = require("@ipld/unixfs/file/layout/balanced");
-    import_ipfs_unixfs_exporter = require("ipfs-unixfs-exporter");
-    queuingStrategy = UnixFS.withCapacity();
-    settings = UnixFS.configure({
-      fileChunkEncoder: raw,
-      smallFileEncoder: raw,
-      chunker: (0, import_fixed.withMaxChunkSize)(1024 * 1024),
-      fileLayout: (0, import_balanced.withWidth)(1024)
-    });
-    UnixFSFileBuilder = class {
-      #file;
-      constructor(name, file) {
-        this.name = name;
-        this.#file = file;
-      }
-      async finalize(writer) {
-        const unixfsFileWriter = UnixFS.createFileWriter(writer);
-        await this.#file.stream().pipeTo(
-          new WritableStream({
-            async write(chunk) {
-              await unixfsFileWriter.write(chunk);
-            }
-          })
-        );
-        return await unixfsFileWriter.close();
-      }
-    };
-  }
-});
-
-// src/runtime/store-file-version.ts
-var FILESTORE_VERSION;
-var init_store_file_version = __esm({
-  "src/runtime/store-file-version.ts"() {
-    "use strict";
-    FILESTORE_VERSION = "v0.19-file";
-  }
-});
-
-// src/runtime/store-indexdb-version.ts
-var INDEXDB_VERSION;
-var init_store_indexdb_version = __esm({
-  "src/runtime/store-indexdb-version.ts"() {
-    "use strict";
-    INDEXDB_VERSION = "v0.19-indexdb";
-  }
-});
-
-// src/runtime/index.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  FILESTORE_VERSION: () => FILESTORE_VERSION,
-  INDEXDB_VERSION: () => INDEXDB_VERSION,
-  SysContainer: () => SysContainer,
-  crypto: () => crypto_exports,
-  dataDir: () => dataDir,
-  ensureIndexName: () => ensureIndexName,
-  files: () => files_exports,
-  getFileName: () => getFileName,
-  getPath: () => getPath,
-  join: () => join
-});
-var init_runtime = __esm({
-  "src/runtime/index.ts"() {
-    "use strict";
-    init_sys_container();
-    init_data_dir();
-    init_store_file_utils();
-    init_crypto();
-    init_files();
-    init_store_file_version();
-    init_store_indexdb_version();
-  }
-});
-
-// src/utils.ts
-function ensureLogger(optsOrLogger, componentName, ctx) {
+function ensureLogger(sthis, componentName, ctx) {
   let logger = globalLogger;
-  if ((0, import_cement2.IsLogger)(optsOrLogger)) {
-    logger = optsOrLogger;
-  } else if (optsOrLogger && (0, import_cement2.IsLogger)(optsOrLogger.logger)) {
-    logger = optsOrLogger.logger;
+  if ((0, import_cement.IsLogger)(sthis)) {
+    logger = sthis;
+  } else if (sthis && (0, import_cement.IsLogger)(sthis.logger)) {
+    logger = sthis.logger;
   }
   const cLogger = logger.With().Module(componentName);
   const debug = [];
+  let exposeStack = false;
   if (ctx) {
     if ("debug" in ctx) {
       if (typeof ctx.debug === "string" && ctx.debug.length > 0) {
@@ -485,8 +83,12 @@ function ensureLogger(optsOrLogger, componentName, ctx) {
       }
       delete ctx.debug;
     }
+    if ("exposeStack" in ctx) {
+      exposeStack = true;
+      delete ctx.exposeStack;
+    }
     if ("this" in ctx) {
-      cLogger.Str("this", (0, import_uuidv72.uuidv7)());
+      cLogger.Str("this", sthis.nextId(4).str);
       delete ctx.this;
     }
     for (const [key, value] of Object.entries(ctx)) {
@@ -500,7 +102,7 @@ function ensureLogger(optsOrLogger, componentName, ctx) {
         default:
           if (value instanceof Date) {
             cLogger.Str(key, value.toISOString());
-          } else if (value instanceof URL) {
+          } else if ((0, import_cement.isURL)(value)) {
             cLogger.Str(key, value.toString());
           } else if (typeof value === "function") {
             cLogger.Ref(key, value);
@@ -512,74 +114,152 @@ function ensureLogger(optsOrLogger, componentName, ctx) {
     }
   }
   registerFP_DEBUG.once(async () => {
-    SysContainer.env.onSet((key, value) => {
-      if (value) {
-        logger.SetDebug(value);
-      }
-    }, "FP_DEBUG");
+    sthis.env.onSet(
+      (key, value) => {
+        switch (key) {
+          case "FP_DEBUG":
+            logger.SetDebug(value || []);
+            break;
+          case "FP_STACK":
+            logger.SetExposeStack(!!value);
+            break;
+        }
+      },
+      "FP_DEBUG",
+      "FP_STACK"
+    );
   }).finally(() => {
   });
   if (debug.length > 0) {
     logger.SetDebug(debug);
   }
+  if (exposeStack) {
+    logger.SetExposeStack(true);
+  }
   const out = cLogger.Logger();
   return out;
 }
-function getStore(url2, logger, joiner) {
-  let result = url2.searchParams.get("store");
-  if (!result) throw logger.Error().Str("url", url2.toString()).Msg(`store not found`).AsError();
-  if (url2.searchParams.has("index")) {
-    result = joiner(url2.searchParams.get("index") || "idx", result);
+function getStore(url, sthis, joiner) {
+  const store = url.getParam("store");
+  switch (store) {
+    case "data":
+    case "wal":
+    case "meta":
+      break;
+    default:
+      throw sthis.logger.Error().Url(url).Msg(`store not found`).AsError();
   }
-  return result;
+  let name = store;
+  if (url.hasParam("index")) {
+    name = joiner(url.getParam("index") || "idx", name);
+  }
+  return { store, name };
 }
-function getKey(url2, logger) {
-  const result = url2.searchParams.get("key");
-  if (!result) throw logger.Error().Str("url", url2.toString()).Msg(`key not found`).AsError();
+function getKey(url, logger) {
+  const result = url.getParam("key");
+  if (!result) throw logger.Error().Str("url", url.toString()).Msg(`key not found`).AsError();
   return result;
 }
-function getName(url2, logger) {
-  let result = url2.searchParams.get("name");
+function getName(sthis, url) {
+  let result = url.getParam("name");
   if (!result) {
-    result = SysContainer.dirname(url2.pathname);
+    result = sthis.pathOps.dirname(url.pathname);
     if (result.length === 0) {
-      throw logger.Error().Str("url", url2.toString()).Msg(`name not found`).AsError();
+      throw sthis.logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
     }
   }
   return result;
 }
 function exception2Result(fn) {
-  return fn().then((value) => import_cement2.Result.Ok(value)).catch((e) => import_cement2.Result.Err(e));
+  return fn().then((value) => import_cement.Result.Ok(value)).catch((e) => import_cement.Result.Err(e));
 }
 async function exceptionWrapper(fn) {
-  return fn().catch((e) => import_cement2.Result.Err(e));
+  return fn().catch((e) => import_cement.Result.Err(e));
 }
-var import_cement2, import_uuidv72, globalLogger, registerFP_DEBUG;
-var init_utils = __esm({
-  "src/utils.ts"() {
-    "use strict";
-    import_cement2 = require("@adviser/cement");
-    init_runtime();
-    import_uuidv72 = require("uuidv7");
-    globalLogger = new import_cement2.LoggerImpl();
-    registerFP_DEBUG = new import_cement2.ResolveOnce();
-  }
-});
-
-// src/blockstore/gateway.ts
 function isNotFoundError(e) {
-  if (import_cement3.Result.Is(e)) {
+  if (import_cement.Result.Is(e)) {
     if (e.isOk()) return false;
     e = e.Err();
   }
   if (e.code === "ENOENT") return true;
   return false;
 }
-var import_cement3, NotFoundError;
-var init_gateway = __esm({
-  "src/blockstore/gateway.ts"() {
+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;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+var import_cement, import_base58, globalLogger, registerFP_DEBUG, superThis, pathOpsImpl, pathOps, txtOps, NotFoundError;
+var init_utils = __esm({
+  "src/utils.ts"() {
     "use strict";
-    import_cement3 = require("@adviser/cement");
+    import_cement = require("@adviser/cement");
+    import_base58 = require("multiformats/bases/base58");
+    globalLogger = new import_cement.LoggerImpl();
+    registerFP_DEBUG = new import_cement.ResolveOnce();
+    superThis = class _superThis {
+      constructor(opts) {
+        this.logger = opts.logger;
+        this.env = opts.env;
+        this.crypto = opts.crypto;
+        this.pathOps = opts.pathOps;
+        this.txt = opts.txt;
+        this.ctx = { ...opts.ctx };
+      }
+      nextId(bytes = 6) {
+        const bin = this.crypto.randomBytes(bytes);
+        return {
+          str: import_base58.base58btc.encode(bin),
+          bin
+        };
+      }
+      start() {
+        return Promise.resolve();
+      }
+      clone(override) {
+        return new _superThis({
+          logger: override.logger || this.logger,
+          env: (0, import_cement.envFactory)(override.env) || this.env,
+          crypto: override.crypto || this.crypto,
+          pathOps: override.pathOps || this.pathOps,
+          txt: override.txt || this.txt,
+          ctx: { ...this.ctx, ...override.ctx }
+        });
+      }
+    };
+    pathOpsImpl = class {
+      join(...paths) {
+        return paths.map((i) => i.replace(/\/+$/, "")).join("/");
+      }
+      dirname(path) {
+        return path.split("/").slice(0, -1).join("/");
+      }
+      // homedir() {
+      //     throw new Error("SysContainer:homedir is not available in seeded state");
+      //   }
+    };
+    pathOps = new pathOpsImpl();
+    txtOps = {
+      encode: (input) => new TextEncoder().encode(input),
+      decode: (input) => new TextDecoder().decode(input)
+    };
     NotFoundError = class extends Error {
       constructor() {
         super(...arguments);
@@ -589,38 +269,149 @@ var init_gateway = __esm({
   }
 });
 
-// src/runtime/store-file.ts
-var store_file_exports = {};
-__export(store_file_exports, {
-  FileDataGateway: () => FileDataGateway,
-  FileMetaGateway: () => FileMetaGateway,
-  FileTestStore: () => FileTestStore,
-  FileWALGateway: () => FileWALGateway
+// src/runtime/gateways/file/mem-filesystem.ts
+var mem_filesystem_exports = {};
+__export(mem_filesystem_exports, {
+  MemFileSystem: () => MemFileSystem
+});
+var import_memfs, MemFileSystem;
+var init_mem_filesystem = __esm({
+  "src/runtime/gateways/file/mem-filesystem.ts"() {
+    "use strict";
+    import_memfs = require("memfs");
+    init_utils2();
+    MemFileSystem = class {
+      async start() {
+        return this;
+      }
+      mkdir(path, options) {
+        return import_memfs.fs.promises.mkdir(path, options);
+      }
+      readdir(path, options) {
+        return import_memfs.fs.promises.readdir(path, options);
+      }
+      rm(path, options) {
+        return import_memfs.fs.promises.rm(path, options);
+      }
+      copyFile(source, destination) {
+        return import_memfs.fs.promises.copyFile(source, destination);
+      }
+      async readfile(path, options) {
+        const ret = await import_memfs.fs.promises.readFile(path, options);
+        return toArrayBuffer(ret);
+      }
+      stat(path) {
+        return import_memfs.fs.promises.stat(path);
+      }
+      unlink(path) {
+        return import_memfs.fs.promises.unlink(path);
+      }
+      writefile(path, data) {
+        return import_memfs.fs.promises.writeFile(path, Buffer.from(data));
+      }
+    };
+  }
+});
+
+// src/runtime/gateways/file/node-filesystem.ts
+var node_filesystem_exports = {};
+__export(node_filesystem_exports, {
+  NodeFileSystem: () => NodeFileSystem
+});
+var NodeFileSystem;
+var init_node_filesystem = __esm({
+  "src/runtime/gateways/file/node-filesystem.ts"() {
+    "use strict";
+    init_utils2();
+    NodeFileSystem = class {
+      async start() {
+        this.fs = await import("fs/promises");
+        return this;
+      }
+      async mkdir(path, options) {
+        return this.fs?.mkdir(path, options);
+      }
+      async readdir(path, options) {
+        return this.fs?.readdir(path, options);
+      }
+      async rm(path, options) {
+        return this.fs?.rm(path, options);
+      }
+      async copyFile(source, destination) {
+        return this.fs?.copyFile(source, destination);
+      }
+      async readfile(path, options) {
+        const ret = await this.fs?.readFile(path, options);
+        return toArrayBuffer(ret);
+      }
+      stat(path) {
+        return this.fs?.stat(path);
+      }
+      async unlink(path) {
+        return this.fs?.unlink(path);
+      }
+      async writefile(path, data) {
+        return this.fs?.writeFile(path, Buffer.from(data));
+      }
+    };
+  }
+});
+
+// src/runtime/gateways/file/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  getFileName: () => getFileName,
+  getFileSystem: () => getFileSystem,
+  getPath: () => getPath,
+  toArrayBuffer: () => toArrayBuffer
 });
-async function ensureVersionFile(path2, logger) {
-  let once = versionFiles.get(path2);
-  if (!once) {
-    once = new import_cement6.ResolveOnce();
-    versionFiles.set(path2, once);
-  }
-  await once.once(async () => {
-    await SysContainer.mkdir(path2, { recursive: true });
-    const vFile = SysContainer.join(path2, "version");
-    const vFileStat = await SysContainer.stat(vFile).catch(() => void 0);
-    if (!vFileStat) {
-      await SysContainer.writefile(SysContainer.join(path2, "version"), FILESTORE_VERSION);
-      return;
-    } else if (!vFileStat.isFile()) {
-      throw logger.Error().Str("file", vFile).Msg(`version file is a directory`).AsError();
-    }
-    const v = await SysContainer.readfile(vFile);
-    if (v.toString() !== FILESTORE_VERSION) {
-      console.warn(`version mismatch:${vFile}: ${v.toString()}!=${FILESTORE_VERSION}`);
+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 "node":
+    case "sys":
+    default: {
+      const { NodeFileSystem: NodeFileSystem2 } = await Promise.resolve().then(() => (init_node_filesystem(), node_filesystem_exports));
+      fs2 = new NodeFileSystem2();
     }
-  });
-  return path2;
+  }
+  return fs2.start();
+}
+function getPath(url, sthis) {
+  const basePath = url.pathname;
+  const name = url.getParam("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);
+}
+function getFileName(url, sthis) {
+  const key = url.getParam("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 "wal":
+    case "meta":
+      return sthis.pathOps.join(res.name, key + ".json");
+    default:
+      throw sthis.logger.Error().Url(url).Msg(`unsupported store type`).AsError();
+  }
 }
 function toArrayBuffer(buffer) {
+  if (typeof buffer === "string") {
+    buffer = Buffer.from(buffer);
+  }
   const ab = new ArrayBuffer(buffer.length);
   const view = new Uint8Array(ab);
   for (let i = 0; i < buffer.length; ++i) {
@@ -628,167 +419,290 @@ function toArrayBuffer(buffer) {
   }
   return view;
 }
-var import_cement6, versionFiles, FileGateway, FileWALGateway, FileMetaGateway, FileDataGateway, FileTestStore;
-var init_store_file = __esm({
-  "src/runtime/store-file.ts"() {
+var init_utils2 = __esm({
+  "src/runtime/gateways/file/utils.ts"() {
+    "use strict";
+    init_utils();
+  }
+});
+
+// src/runtime/key-bag-file.ts
+var key_bag_file_exports = {};
+__export(key_bag_file_exports, {
+  KeyBagProviderFile: () => KeyBagProviderFile
+});
+var KeyBagProviderFile;
+var init_key_bag_file = __esm({
+  "src/runtime/key-bag-file.ts"() {
+    "use strict";
+    init_utils();
+    KeyBagProviderFile = class {
+      async _prepare(id) {
+        await this.sthis.start();
+        let sysFS;
+        switch (this.url.protocol) {
+          case "file:": {
+            const { getFileSystem: getFileSystem2 } = await Promise.resolve().then(() => (init_utils2(), utils_exports));
+            sysFS = await getFileSystem2(this.url);
+            break;
+          }
+          default:
+            throw this.logger.Error().Url(this.url).Msg("unsupported protocol").AsError();
+        }
+        const dirName = this.url.pathname;
+        await sysFS.mkdir(dirName, { recursive: true });
+        return {
+          dirName,
+          sysFS,
+          fName: this.sthis.pathOps.join(dirName, `${id.replace(/[^a-zA-Z0-9]/g, "_")}.json`)
+        };
+      }
+      constructor(url, sthis) {
+        this.url = url;
+        this.sthis = sthis;
+        this.logger = sthis.logger;
+      }
+      async get(id) {
+        const ctx = await this._prepare(id);
+        try {
+          const p = await ctx.sysFS.readfile(ctx.fName);
+          const ki = JSON.parse(this.sthis.txt.decode(p));
+          return ki;
+        } catch (e) {
+          if (isNotFoundError(e)) {
+            return void 0;
+          }
+          throw this.logger.Error().Err(e).Str("file", ctx.dirName).Msg("read bag failed").AsError();
+        }
+      }
+      async set(id, item) {
+        const ctx = await this._prepare(id);
+        const p = this.sthis.txt.encode(JSON.stringify(item, null, 2));
+        await ctx.sysFS.writefile(ctx.fName, p);
+      }
+    };
+  }
+});
+
+// src/runtime/key-bag-indexdb.ts
+var key_bag_indexdb_exports = {};
+__export(key_bag_indexdb_exports, {
+  KeyBagProviderIndexDB: () => KeyBagProviderIndexDB
+});
+var import_idb, import_cement4, KeyBagProviderIndexDB;
+var init_key_bag_indexdb = __esm({
+  "src/runtime/key-bag-indexdb.ts"() {
+    "use strict";
+    import_idb = require("idb");
+    init_utils2();
+    import_cement4 = require("@adviser/cement");
+    KeyBagProviderIndexDB = class {
+      constructor(url, sthis) {
+        this._db = new import_cement4.ResolveOnce();
+        this.sthis = sthis;
+        this.logger = sthis.logger;
+        this.url = url;
+        this.dbName = getPath(this.url, this.sthis);
+      }
+      async _prepare() {
+        return this._db.once(async () => {
+          return await (0, import_idb.openDB)(this.dbName, 1, {
+            upgrade(db) {
+              ["bag"].map((store) => {
+                db.createObjectStore(store, {
+                  autoIncrement: false
+                });
+              });
+            }
+          });
+        });
+      }
+      async get(id) {
+        const db = await this._prepare();
+        const tx = db.transaction(["bag"], "readonly");
+        const keyItem = await tx.objectStore("bag").get(id);
+        await tx.done;
+        if (!keyItem) {
+          return void 0;
+        }
+        return keyItem;
+      }
+      async set(id, item) {
+        const db = await this._prepare();
+        const tx = db.transaction(["bag"], "readwrite");
+        await tx.objectStore("bag").put(item, id);
+        await tx.done;
+      }
+    };
+  }
+});
+
+// src/runtime/gateways/file/version.ts
+var FILESTORE_VERSION;
+var init_version = __esm({
+  "src/runtime/gateways/file/version.ts"() {
     "use strict";
-    init_sys_container();
-    init_store_file_version();
-    import_cement6 = require("@adviser/cement");
+    FILESTORE_VERSION = "v0.19-file";
+  }
+});
+
+// src/runtime/gateways/file/gateway.ts
+var gateway_exports = {};
+__export(gateway_exports, {
+  FileGateway: () => FileGateway,
+  FileTestStore: () => FileTestStore
+});
+var import_cement8, versionFiles, FileGateway, FileTestStore;
+var init_gateway = __esm({
+  "src/runtime/gateways/file/gateway.ts"() {
+    "use strict";
+    init_version();
+    import_cement8 = require("@adviser/cement");
     init_utils();
-    init_gateway();
-    init_store_file_utils();
-    versionFiles = /* @__PURE__ */ new Map();
+    init_utils2();
+    versionFiles = new import_cement8.KeyedResolvOnce();
     FileGateway = class {
-      constructor(logger) {
-        this.logger = logger;
+      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;
+      }
+      async getVersionFromFile(path, logger) {
+        return versionFiles.get(path).once(async () => {
+          await this.fs.mkdir(path, { recursive: true });
+          const vFile = this.sthis.pathOps.join(path, "version");
+          const vFileStat = await this.fs.stat(vFile).catch(() => void 0);
+          if (!vFileStat) {
+            await this.fs.writefile(this.sthis.pathOps.join(path, "version"), FILESTORE_VERSION);
+            return FILESTORE_VERSION;
+          } else if (!vFileStat.isFile()) {
+            throw logger.Error().Str("file", vFile).Msg(`version file is a directory`).AsError();
+          }
+          const v = await this.fs.readfile(vFile);
+          const vStr = new TextDecoder().decode(v);
+          if (vStr !== FILESTORE_VERSION) {
+            logger.Warn().Str("file", vFile).Str("from", vStr).Str("expected", FILESTORE_VERSION).Msg(`version mismatch`);
+          }
+          return vStr;
+        });
       }
       start(baseURL) {
         return exception2Result(async () => {
-          await SysContainer.start();
-          baseURL.searchParams.set("version", baseURL.searchParams.get("version") || FILESTORE_VERSION);
-          const url2 = await this.buildUrl(baseURL, "dummy");
-          if (url2.isErr()) return url2;
-          const dbdir = this.getFilePath(url2.Ok());
-          await SysContainer.mkdir(SysContainer.dirname(dbdir), { recursive: true });
-          const dbroot = SysContainer.dirname(dbdir);
-          this.logger.Debug().Str("url", url2.Ok().toString()).Str("dbroot", SysContainer.dirname(dbroot)).Msg("start");
-          await ensureVersionFile(dbroot, this.logger);
+          this._fs = await getFileSystem(baseURL);
+          await this.fs.start();
+          const url = baseURL.build();
+          url.defParam("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));
+          return url.URI();
         });
       }
+      async buildUrl(baseUrl, key) {
+        return import_cement8.Result.Ok(baseUrl.build().setParam("key", key).URI());
+      }
       async close() {
-        return import_cement6.Result.Ok(void 0);
+        return import_cement8.Result.Ok(void 0);
       }
-      getFilePath(url2) {
-        const path2 = url2.toString().replace(/^file:\/\//, "").replace(/\?.*$/, "");
-        this.logger.Debug().Str("url", url2.toString()).Str("path", path2).Msg("getFilePath");
-        return path2;
+      // abstract buildUrl(baseUrl: URL, key: string): Promise<Result<URL>>;
+      getFilePath(url) {
+        const key = url.getParam("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(url2, body) {
+      async put(url, body) {
         return exception2Result(async () => {
-          const file = this.getFilePath(url2);
-          this.logger.Debug().Str("url", url2.toString()).Str("file", file).Msg("put");
-          await SysContainer.writefile(file, body);
+          const file = await this.getFilePath(url);
+          this.logger.Debug().Str("url", url.toString()).Str("file", file).Msg("put");
+          await this.fs.writefile(file, body);
         });
       }
-      async get(url2) {
+      async get(url) {
         return exceptionWrapper(async () => {
-          const file = this.getFilePath(url2);
+          const file = this.getFilePath(url);
           try {
-            const res = await SysContainer.readfile(file);
-            this.logger.Debug().Url(url2).Str("file", file).Msg("get");
-            return import_cement6.Result.Ok(new Uint8Array(res));
+            const res = await this.fs.readfile(file);
+            this.logger.Debug().Url(url.asURL()).Str("file", file).Msg("get");
+            return import_cement8.Result.Ok(new Uint8Array(res));
           } catch (e) {
             if (isNotFoundError(e)) {
-              return import_cement6.Result.Err(new NotFoundError(`file not found: ${file}`));
+              return import_cement8.Result.Err(new NotFoundError(`file not found: ${file}`));
             }
-            return import_cement6.Result.Err(e);
+            return import_cement8.Result.Err(e);
           }
         });
       }
-      async delete(url2) {
+      async delete(url) {
         return exception2Result(async () => {
-          await SysContainer.unlink(this.getFilePath(url2));
+          await this.fs.unlink(this.getFilePath(url));
         });
       }
-      async destroyDir(baseURL) {
-        const url2 = await this.buildUrl(baseURL, "x");
-        if (url2.isErr()) return url2;
-        const filepath = SysContainer.dirname(this.getFilePath(url2.Ok()));
-        let dir = [];
+      async destroy(baseURL) {
+        const url = await this.buildUrl(baseURL, "x");
+        if (url.isErr()) return url;
+        const filepath = this.sthis.pathOps.dirname(this.getFilePath(url.Ok()));
+        let files = [];
         try {
-          dir = await SysContainer.readdir(filepath);
+          files = await this.fs.readdir(filepath);
         } catch (e) {
           if (!isNotFoundError(e)) {
             throw this.logger.Error().Err(e).Str("dir", filepath).Msg("destroy:readdir").AsError();
           }
         }
-        for (const file of dir) {
-          const pathed = SysContainer.join(filepath, file);
+        for (const file of files) {
+          const pathed = this.sthis.pathOps.join(filepath, file);
           try {
-            await SysContainer.unlink(pathed);
+            await this.fs.unlink(pathed);
           } catch (e) {
             if (!isNotFoundError(e)) {
               throw this.logger.Error().Err(e).Str("file", pathed).Msg("destroy:unlink").AsError();
             }
           }
         }
-        return import_cement6.Result.Ok(void 0);
-      }
-    };
-    FileWALGateway = class extends FileGateway {
-      constructor(logger) {
-        super(ensureLogger(logger, "FileWALGateway"));
-      }
-      async destroy(baseURL) {
-        return this.destroyDir(baseURL);
-      }
-      async buildUrl(baseUrl, key) {
-        const url2 = new URL(baseUrl.toString());
-        url2.pathname = SysContainer.join(await getPath(baseUrl, this.logger), ensureIndexName(baseUrl, "wal"), key + ".json");
-        return import_cement6.Result.Ok(url2);
-      }
-    };
-    FileMetaGateway = class extends FileGateway {
-      constructor(logger) {
-        super(ensureLogger(logger, "FileMetaGateway"));
-      }
-      async destroy(baseURL) {
-        return this.destroyDir(baseURL);
-      }
-      async buildUrl(baseUrl, key) {
-        const url2 = new URL(baseUrl.toString());
-        url2.pathname = SysContainer.join(await getPath(baseUrl, this.logger), ensureIndexName(baseUrl, "meta"), key + ".json");
-        return import_cement6.Result.Ok(url2);
-      }
-    };
-    FileDataGateway = class extends FileGateway {
-      constructor(logger) {
-        super(ensureLogger(logger, "FileDataGateway"));
-        this.branches = /* @__PURE__ */ new Set();
-      }
-      async destroy(baseURL) {
-        return this.destroyDir(baseURL);
-      }
-      async buildUrl(baseUrl, key) {
-        const url2 = new URL(baseUrl.toString());
-        url2.pathname = SysContainer.join(await getPath(baseUrl, this.logger), ensureIndexName(baseUrl, "data"), key + ".car");
-        return import_cement6.Result.Ok(url2);
+        return import_cement8.Result.Ok(void 0);
       }
     };
     FileTestStore = class {
-      constructor(logger) {
-        this.logger = ensureLogger(logger, "FileTestStore");
-      }
-      async get(url2, key) {
-        const logger = ensureLogger(this.logger, "get", { url: url2.toString(), key });
-        const dbFile = SysContainer.join(
-          await getPath(url2, this.logger),
-          getStore(url2, this.logger, SysContainer.join),
-          getFileName(url2, key, this.logger)
-        );
-        logger.Debug().Str("dbFile", dbFile).Msg("get");
-        const buffer = await SysContainer.readfile(dbFile);
-        logger.Debug().Str("dbFile", dbFile).Len(buffer).Msg("got");
-        return toArrayBuffer(buffer);
+      constructor(sthis) {
+        this.logger = ensureLogger(sthis, "FileTestStore");
+        this.sthis = sthis;
+      }
+      async get(iurl, key) {
+        const url = iurl.build().setParam("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);
+        this.logger.Debug().Url(url).Str("dbFile", dbFile).Len(buffer).Msg("got");
+        return buffer;
       }
     };
   }
 });
 
-// src/runtime/store-indexdb.ts
-var store_indexdb_exports = {};
-__export(store_indexdb_exports, {
-  IndexDBDataGateway: () => IndexDBDataGateway,
-  IndexDBMetaGateway: () => IndexDBMetaGateway,
+// src/runtime/gateways/indexdb/version.ts
+var INDEXDB_VERSION;
+var init_version2 = __esm({
+  "src/runtime/gateways/indexdb/version.ts"() {
+    "use strict";
+    INDEXDB_VERSION = "v0.19-indexdb";
+  }
+});
+
+// src/runtime/gateways/indexdb/gateway.ts
+var gateway_exports2 = {};
+__export(gateway_exports2, {
+  IndexDBGateway: () => IndexDBGateway,
   IndexDBTestStore: () => IndexDBTestStore,
-  IndexDBWalGateway: () => IndexDBWalGateway,
   getIndexDBName: () => getIndexDBName
 });
-function ensureVersion(url2) {
-  const ret = new URL(url2.toString());
-  ret.searchParams.set("version", url2.searchParams.get("version") || INDEXDB_VERSION);
-  return ret;
+function ensureVersion(url) {
+  return url.build().defParam("version", INDEXDB_VERSION).URI();
 }
 function sanitzeKey(key) {
   if (key.length === 1) {
@@ -796,10 +710,10 @@ function sanitzeKey(key) {
   }
   return key;
 }
-async function connectIdb(url2, logger) {
-  const dbName = getIndexDBName(url2, logger);
+async function connectIdb(url, sthis) {
+  const dbName = getIndexDBName(url, sthis);
   const once = await onceIndexDB.get(dbName.fullDb).once(async () => {
-    const db = await (0, import_idb.openDB)(dbName.fullDb, 1, {
+    const db = await (0, import_idb2.openDB)(dbName.fullDb, 1, {
       upgrade(db2) {
         ["version", "data", "wal", "meta", "idx.data", "idx.wal", "idx.meta"].map((store) => {
           db2.createObjectStore(store, {
@@ -809,27 +723,29 @@ async function connectIdb(url2, logger) {
       }
     });
     const found = await db.get("version", "version");
-    const version = url2.searchParams.get("version") || INDEXDB_VERSION;
+    const version = ensureVersion(url).getParam("version");
     if (!found) {
       await db.put("version", { version }, "version");
     } else if (found.version !== version) {
-      logger.Warn().Str("url", url2.toString()).Str("version", version).Str("found", found.version).Msg("version mismatch");
+      sthis.logger.Warn().Str("url", url.toString()).Str("version", version).Str("found", found.version).Msg("version mismatch");
     }
-    return { db, dbName, version };
+    return { db, dbName, version, url };
   });
-  url2.searchParams.set("version", once.version);
-  return once.db;
+  return {
+    ...once,
+    url: url.build().setParam("version", once.version).URI()
+  };
 }
 function joinDBName(...names) {
   return names.map((i) => i.replace(/^[^a-zA-Z0-9]+/g, "").replace(/[^a-zA-Z0-9]+/g, "_")).filter((i) => i.length).join(".");
 }
-function getIndexDBName(iurl, logger) {
-  const url2 = ensureVersion(iurl);
-  const fullDb = url2.pathname.replace(/^\/+/, "").replace(/\?.*$/, "");
-  const dbName = url2.searchParams.get("name");
-  if (!dbName) throw logger.Error().Str("url", url2.toString()).Msg(`name not found`).AsError();
+function getIndexDBName(iurl, sthis) {
+  const url = ensureVersion(iurl);
+  const fullDb = url.pathname.replace(/^\/+/, "").replace(/\?.*$/, "");
+  const dbName = url.getParam("name");
+  if (!dbName) throw sthis.logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
   const result = joinDBName(fullDb, dbName);
-  const objStore = getStore(url2, logger, joinDBName);
+  const objStore = getStore(url, sthis, joinDBName).name;
   const connectionKey = [result, objStore].join(":");
   return {
     fullDb: result,
@@ -838,40 +754,38 @@ function getIndexDBName(iurl, logger) {
     dbName
   };
 }
-var import_idb, import_cement7, onceIndexDB, IndexDBGateway, IndexDBDataGateway, IndexDBWalGateway, IndexDBMetaGateway, txtEncoder, IndexDBTestStore;
-var init_store_indexdb = __esm({
-  "src/runtime/store-indexdb.ts"() {
+var import_idb2, import_cement9, onceIndexDB, IndexDBGateway, IndexDBTestStore;
+var init_gateway2 = __esm({
+  "src/runtime/gateways/indexdb/gateway.ts"() {
     "use strict";
-    import_idb = require("idb");
-    import_cement7 = require("@adviser/cement");
-    init_store_indexdb_version();
+    import_idb2 = require("idb");
+    import_cement9 = require("@adviser/cement");
+    init_version2();
     init_utils();
-    init_gateway();
-    init_sys_container();
-    onceIndexDB = new import_cement7.KeyedResolvOnce();
+    onceIndexDB = new import_cement9.KeyedResolvOnce();
     IndexDBGateway = class {
-      constructor(logger) {
-        this.db = {};
-        this.logger = logger;
-      }
-      idb() {
-        this.db;
+      constructor(sthis) {
+        this._db = {};
+        this.logger = ensureLogger(sthis, "IndexDBGateway");
+        this.sthis = sthis;
       }
       async start(baseURL) {
         return exception2Result(async () => {
           this.logger.Debug().Url(baseURL).Msg("starting");
-          await SysContainer.start();
-          this.db = await connectIdb(baseURL, this.logger);
-          this.logger.Debug().Url(baseURL).Msg("started");
+          await this.sthis.start();
+          const ic = await connectIdb(baseURL, this.sthis);
+          this._db = ic.db;
+          this.logger.Debug().Url(ic.url).Msg("started");
+          return ic.url;
         });
       }
       async close() {
-        return import_cement7.Result.Ok(void 0);
+        return import_cement9.Result.Ok(void 0);
       }
       async destroy(baseUrl) {
         return exception2Result(async () => {
-          const type = getStore(baseUrl, this.logger, joinDBName);
-          const idb = this.db;
+          const type = getStore(baseUrl, this.sthis, joinDBName).name;
+          const idb = this._db;
           const trans = idb.transaction(type, "readwrite");
           const object_store = trans.objectStore(type);
           const toDelete = [];
@@ -884,87 +798,58 @@ var init_store_indexdb = __esm({
           await trans.done;
         });
       }
-      async get(url2) {
+      buildUrl(baseUrl, key) {
+        return Promise.resolve(import_cement9.Result.Ok(baseUrl.build().setParam("key", key).URI()));
+      }
+      async get(url) {
         return exceptionWrapper(async () => {
-          const key = getKey(url2, this.logger);
-          const store = getStore(url2, this.logger, joinDBName);
-          this.logger.Debug().Url(url2).Str("key", key).Str("store", store).Msg("getting");
-          const tx = this.db.transaction([store], "readonly");
+          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("getting");
+          const tx = this._db.transaction([store], "readonly");
           const bytes = await tx.objectStore(store).get(sanitzeKey(key));
           await tx.done;
           if (!bytes) {
-            return import_cement7.Result.Err(new NotFoundError(`missing ${key}`));
+            return import_cement9.Result.Err(new NotFoundError(`missing ${key}`));
           }
-          return import_cement7.Result.Ok(bytes);
+          return import_cement9.Result.Ok(bytes);
         });
       }
-      async put(url2, value) {
+      async put(url, value) {
         return exception2Result(async () => {
-          const key = getKey(url2, this.logger);
-          const store = getStore(url2, this.logger, joinDBName);
-          this.logger.Debug().Url(url2).Str("key", key).Str("store", store).Msg("putting");
-          const tx = this.db.transaction([store], "readwrite");
+          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");
+          const tx = this._db.transaction([store], "readwrite");
           await tx.objectStore(store).put(value, sanitzeKey(key));
           await tx.done;
         });
       }
-      async delete(url2) {
+      async delete(url) {
         return exception2Result(async () => {
-          const key = getKey(url2, this.logger);
-          const store = getStore(url2, this.logger, joinDBName);
-          this.logger.Debug().Url(url2).Str("key", key).Str("store", store).Msg("deleting");
-          const tx = this.db.transaction([store], "readwrite");
+          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_cement7.Result.Ok(void 0);
+          return import_cement9.Result.Ok(void 0);
         });
       }
     };
-    IndexDBDataGateway = class extends IndexDBGateway {
-      constructor(logger) {
-        super(ensureLogger(logger, "IndexDBDataGateway", {}));
-      }
-      buildUrl(baseUrl, key) {
-        const url2 = new URL(baseUrl.toString());
-        url2.searchParams.set("key", key);
-        return Promise.resolve(import_cement7.Result.Ok(url2));
-      }
-    };
-    IndexDBWalGateway = class extends IndexDBGateway {
-      constructor(logger) {
-        super(ensureLogger(logger, "IndexDBWalGateway", {}));
-      }
-      buildUrl(baseUrl, key) {
-        const url2 = new URL(baseUrl.toString());
-        url2.searchParams.set("key", key);
-        return Promise.resolve(import_cement7.Result.Ok(url2));
-      }
-    };
-    IndexDBMetaGateway = class extends IndexDBGateway {
-      constructor(logger) {
-        super(ensureLogger(logger, "IndexDBDataGateway", {}));
-        this.branches = /* @__PURE__ */ new Set();
-      }
-      async buildUrl(baseUrl, key) {
-        const url2 = new URL(baseUrl.toString());
-        this.branches.add(key);
-        url2.searchParams.set("key", key);
-        return import_cement7.Result.Ok(url2);
-      }
-    };
-    txtEncoder = new TextEncoder();
     IndexDBTestStore = class {
-      constructor(logger) {
-        this.logger = ensureLogger(logger, "IndexDBTestStore", {});
+      constructor(sthis) {
+        this.sthis = sthis;
+        this.logger = ensureLogger(sthis, "IndexDBTestStore", {});
       }
-      async get(url2, key) {
-        const db = await connectIdb(url2, this.logger);
-        const store = getStore(url2, this.logger, joinDBName);
+      async get(url, key) {
+        const ic = await connectIdb(url, this.sthis);
+        const store = getStore(ic.url, this.sthis, joinDBName).name;
         this.logger.Debug().Str("key", key).Str("store", store).Msg("getting");
-        let bytes = await db.get(store, sanitzeKey(key));
+        let bytes = await ic.db.get(store, sanitzeKey(key));
         this.logger.Debug().Str("key", key).Str("store", store).Int("len", bytes.length).Msg("got");
         if (typeof bytes === "string") {
-          bytes = txtEncoder.encode(bytes);
+          bytes = this.sthis.txt.encode(bytes);
         }
         return bytes;
       }
@@ -978,11 +863,16 @@ __export(src_exports, {
   CRDT: () => CRDT,
   Database: () => Database,
   Index: () => Index,
+  NotFoundError: () => NotFoundError,
   PACKAGE_VERSION: () => PACKAGE_VERSION,
-  Result: () => import_cement2.Result,
+  Result: () => import_cement.Result,
+  UInt8ArrayEqual: () => UInt8ArrayEqual,
   blockstore: () => blockstore_exports,
   bs: () => blockstore_exports,
+  dataDir: () => dataDir,
   ensureLogger: () => ensureLogger,
+  ensureSuperLog: () => ensureSuperLog,
+  ensureSuperThis: () => ensureSuperThis,
   exception2Result: () => exception2Result,
   exceptionWrapper: () => exceptionWrapper,
   falsyToUndef: () => falsyToUndef,
@@ -992,6 +882,7 @@ __export(src_exports, {
   getStore: () => getStore,
   index: () => index,
   isFalsy: () => isFalsy,
+  isNotFoundError: () => isNotFoundError,
   rt: () => runtime_exports,
   runtime: () => runtime_exports,
   throwFalsy: () => throwFalsy
@@ -999,8 +890,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/database.ts
-var import_uuidv73 = require("uuidv7");
-var import_cement11 = require("@adviser/cement");
+var import_cement13 = require("@adviser/cement");
 
 // src/write-queue.ts
 function writeQueue(worker, payload = Infinity, unbounded = false) {
@@ -1043,13 +933,83 @@ function writeQueue(worker, payload = Infinity, unbounded = false) {
 }
 
 // src/crdt.ts
-var import_cement10 = require("@adviser/cement");
+var import_cement12 = 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_block6 = require("multiformats/block");
 var import_link = require("multiformats/link");
-var import_sha23 = require("multiformats/hashes/sha2");
-var codec2 = __toESM(require("@ipld/dag-cbor"), 1);
+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);
@@ -1060,525 +1020,149 @@ __export(blockstore_exports, {
   BaseBlockstore: () => BaseBlockstore,
   CarTransaction: () => CarTransaction,
   CompactionFetcher: () => CompactionFetcher,
-  ConnectREST: () => ConnectREST,
   ConnectionBase: () => ConnectionBase,
-  DataStore: () => DataStore,
   EncryptedBlockstore: () => EncryptedBlockstore,
-  Loadable: () => Loadable,
+  FragmentGateway: () => FragmentGateway,
   Loader: () => Loader,
-  MetaStore: () => MetaStore,
-  NotFoundError: () => NotFoundError,
-  RemoteWAL: () => RemoteWAL,
-  isNotFoundError: () => isNotFoundError,
+  ensureStart: () => ensureStart,
+  getGatewayFromURL: () => getGatewayFromURL,
   parseCarFile: () => parseCarFile,
   registerStoreProtocol: () => registerStoreProtocol,
   testStoreFactory: () => testStoreFactory,
-  toStoreRuntime: () => toStoreRuntime,
-  toURL: () => toURL
+  toCIDBlock: () => toCIDBlock,
+  toStoreRuntime: () => toStoreRuntime
 });
 
-// src/blockstore/connection-base.ts
-var import_clock = require("@web3-storage/pail/clock");
-var import_block = require("@web3-storage/pail/block");
-init_types();
+// src/blockstore/types.ts
+function toCIDBlock(block) {
+  return block;
+}
 
-// src/blockstore/task-manager.ts
-init_utils();
-var TaskManager = class {
-  constructor(loader) {
-    this.eventsWeHandled = /* @__PURE__ */ new Set();
-    this.queue = [];
-    this.isProcessing = false;
-    this.loader = loader;
-    this.logger = ensureLogger(loader.logger, "TaskManager");
-  }
-  async handleEvent(eventBlock) {
-    const cid = eventBlock.cid.toString();
-    const parents = eventBlock.value.parents.map((cid2) => cid2.toString());
-    for (const parent of parents) {
-      this.eventsWeHandled.add(parent);
-    }
-    this.queue.push({ cid, eventBlock, 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 {
-      this.loader?.remoteMetaStore?.handleByteHeads([first.eventBlock.value.data.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();
-      }
-    }
-  }
-};
+// src/blockstore/store-factory.ts
+var import_cement10 = require("@adviser/cement");
 
-// src/blockstore/connection-base.ts
-init_utils();
-var ConnectionBase = class {
-  constructor(logger) {
-    // readonly ready: Promise<unknown>;
-    // todo move to LRU blockstore https://github.com/web3-storage/w3clock/blob/main/src/worker/block.js
-    this.eventBlocks = new import_block.MemoryBlockstore();
-    this.parents = [];
-    this.loaded = Promise.resolve();
-    this.logger = ensureLogger(logger, "ConnectionBase");
-  }
-  async refresh() {
-    await throwFalsy(throwFalsy(this.loader).remoteMetaStore).load("main");
-    await (await throwFalsy(this.loader).remoteWAL())._process();
-  }
-  connect({ loader }) {
-    if (!loader) throw this.logger.Error().Msg("loader is required").AsError();
-    this.connectMeta({ loader });
-    this.connectStorage({ loader });
-  }
-  connectMeta({ loader }) {
-    if (!loader) throw this.logger.Error().Msg("loader is required").AsError();
-    this.loader = loader;
-    this.taskManager = new TaskManager(loader);
-    this.onConnect();
-    this.logger.Warn().Msg("connectMeta: connecting to remote meta store is disabled");
-  }
-  async onConnect() {
-    return;
-  }
-  connectStorage({ loader }) {
-    if (!loader) throw this.logger.Error().Msg("loader is required").AsError();
-    this.loader = loader;
-    this.logger.Warn().Msg("connectStorage: connecting to remote meta store is disabled");
+// src/runtime/files.ts
+var files_exports = {};
+__export(files_exports, {
+  decodeFile: () => decodeFile,
+  encodeFile: () => encodeFile
+});
+var UnixFS = __toESM(require("@ipld/unixfs"), 1);
+var raw = __toESM(require("multiformats/codecs/raw"), 1);
+var import_fixed = require("@ipld/unixfs/file/chunker/fixed");
+var import_balanced = require("@ipld/unixfs/file/layout/balanced");
+var import_ipfs_unixfs_exporter = require("ipfs-unixfs-exporter");
+var queuingStrategy = UnixFS.withCapacity();
+var settings = UnixFS.configure({
+  fileChunkEncoder: raw,
+  smallFileEncoder: raw,
+  chunker: (0, import_fixed.withMaxChunkSize)(1024 * 1024),
+  fileLayout: (0, import_balanced.withWidth)(1024)
+});
+async function collect(collectable) {
+  const chunks = [];
+  await collectable.pipeTo(
+    new WritableStream({
+      write(chunk) {
+        chunks.push(chunk);
+      }
+    })
+  );
+  return chunks;
+}
+async function encodeFile(blob) {
+  const readable = createFileEncoderStream(blob);
+  const blocks = await collect(readable);
+  return { cid: blocks.at(-1).cid, blocks };
+}
+async function decodeFile(blocks, cid, meta) {
+  const entry = await (0, import_ipfs_unixfs_exporter.exporter)(cid.toString(), blocks, { length: meta.size });
+  const chunks = [];
+  for await (const chunk of entry.content()) {
+    chunks.push(chunk);
   }
-  async createEventBlock(bytes) {
-    const data = {
-      dbMeta: bytes
-    };
-    const event = await import_clock.EventBlock.create(
-      data,
-      this.parents
+  return new File(chunks, entry.name, { type: meta.type, lastModified: 0 });
+}
+function createFileEncoderStream(blob) {
+  const { readable, writable } = new TransformStream({}, queuingStrategy);
+  const unixfsWriter = UnixFS.createWriter({ writable, settings });
+  const fileBuilder = new UnixFSFileBuilder("", blob);
+  void (async () => {
+    await fileBuilder.finalize(unixfsWriter);
+    await unixfsWriter.close();
+  })();
+  return readable;
+}
+var UnixFSFileBuilder = class {
+  #file;
+  constructor(name, file) {
+    this.name = name;
+    this.#file = file;
+  }
+  async finalize(writer) {
+    const unixfsFileWriter = UnixFS.createFileWriter(writer);
+    await this.#file.stream().pipeTo(
+      new WritableStream({
+        async write(chunk) {
+          await unixfsFileWriter.write(chunk);
+        }
+      })
     );
-    await this.eventBlocks.put(event.cid, event.bytes);
-    return event;
-  }
-  async decodeEventBlock(bytes) {
-    const event = await (0, import_clock.decodeEventBlock)(bytes);
-    return event;
+    return await unixfsFileWriter.close();
   }
-  // move this stuff to connect
-  // async getDashboardURL(compact = true) {
-  //   const baseUrl = 'https://dashboard.fireproof.storage/'
-  //   if (!this.loader?.remoteCarStore) return new URL('/howto', baseUrl)
-  //   // if (compact) {
-  //   //   await this.compact()
-  //   // }
-  //   const currents = await this.loader?.metaStore?.load()
-  //   if (!currents) throw new Error("Can't sync empty database: save data first")
-  //   if (currents.length > 1)
-  //     throw new Error("Can't sync database with split heads: make an update first")
-  //   const current = currents[0]
-  //   const params = {
-  //     car: current.car.toString()
-  //   }
-  //   if (current.key) {
-  //     // @ts-ignore
-  //     params.key = current.key.toString()
-  //   }
-  //   // @ts-ignore
-  //   if (this.name) {
-  //     // @ts-ignore
-  //     params.name = this.name
-  //   }
-  //   const url = new URL('/import#' + new URLSearchParams(params).toString(), baseUrl)
-  //   console.log('Import to dashboard: ' + url.toString())
-  //   return url
-  // }
-  // openDashboard() {
-  //   void this.getDashboardURL().then(url => {
-  //     if (url) window.open(url.toString(), '_blank')
-  //   })
-  // }
 };
 
-// src/blockstore/connect-rest.ts
-init_utils();
-var ConnectREST = class extends ConnectionBase {
-  constructor(base, logger) {
-    super(ensureLogger(logger, "ConnectREST"));
-    this.baseUrl = new URL(base);
-  }
-  async dataUpload(bytes, params) {
-    const carCid = params.car.toString();
-    const uploadURL = new URL(`/cars/${carCid}.car`, this.baseUrl);
-    const done = await fetch(uploadURL, { method: "PUT", body: bytes });
-    if (!done.ok) {
-      throw this.logger.Error().Msg("failed to upload data " + done.statusText);
-    }
-  }
-  async dataDownload(params) {
-    const { car } = params;
-    const fetchFromUrl = new URL(`/cars/${car.toString()}.car`, this.baseUrl);
-    const response = await fetch(fetchFromUrl);
-    if (!response.ok) {
-      return void 0;
-    }
-    const bytes = new Uint8Array(await response.arrayBuffer());
-    return bytes;
+// src/blockstore/store.ts
+var import_p_limit2 = __toESM(require("p-limit"), 1);
+var import_dag_json = require("@ipld/dag-json");
+var import_cement7 = 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");
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async metaUpload(bytes, params) {
+  return value;
+}
+function falsyToUndef(value) {
+  if (isFalsy(value)) {
     return void 0;
   }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async metaDownload(params) {
-    return [];
-  }
-};
-
-// src/blockstore/store-factory.ts
-var import_cement8 = require("@adviser/cement");
-init_data_dir();
-init_files();
+  return value;
+}
 
 // src/blockstore/store.ts
-var import_p_limit2 = __toESM(require("p-limit"), 1);
-var import_dag_json = require("@ipld/dag-json");
-var import_cement5 = require("@adviser/cement");
-init_types();
-init_gateway();
 init_utils();
 
 // src/blockstore/loader.ts
 var import_p_limit = __toESM(require("p-limit"), 1);
 var import_car = require("@ipld/car");
-var import_cement4 = require("@adviser/cement");
-
-// src/blockstore/types.ts
-function toCIDBlock(block) {
-  return block;
-}
+var import_cement6 = require("@adviser/cement");
 
 // src/blockstore/loader-helpers.ts
-var import_block2 = require("multiformats/block");
 var import_sha2 = require("multiformats/hashes/sha2");
-var raw2 = __toESM(require("multiformats/codecs/raw"), 1);
-var CBW = __toESM(require("@ipld/car/buffer-writer"), 1);
-var codec = __toESM(require("@ipld/dag-cbor"), 1);
-async function encodeCarFile(roots, t) {
-  let size = 0;
-  const headerSize = CBW.headerLength({ roots });
-  size += headerSize;
-  for (const { cid, bytes } of t.entries()) {
-    size += CBW.blockLength({ cid, bytes });
-  }
-  const buffer = new Uint8Array(size);
-  const writer = CBW.createWriter(buffer, { headerSize });
-  for (const r of roots) {
-    writer.addRoot(r);
-  }
-  for (const { cid, bytes } of t.entries()) {
-    writer.write({ cid, bytes });
-  }
-  writer.close();
-  return await (0, import_block2.encode)({ value: writer.bytes, hasher: import_sha2.sha256, codec: raw2 });
-}
-async function encodeCarHeader(fp) {
-  return await (0, import_block2.encode)({
-    value: { fp },
-    hasher: import_sha2.sha256,
-    codec
-  });
-}
+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 { value } = await (0, import_block2.decode)({ bytes: header.bytes, hasher: import_sha2.sha256, codec });
-  const fpvalue = value;
+  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/encrypt-helpers.ts
-var import_sha22 = require("multiformats/hashes/sha2");
-var import_multiformats2 = require("multiformats");
-var import_block3 = require("multiformats/block");
-var dagcbor = __toESM(require("@ipld/dag-cbor"), 1);
-var import_block4 = require("@web3-storage/pail/block");
-var import_utils6 = require("prolly-trees/utils");
-var import_cache = require("prolly-trees/cache");
-var import_cid_set = require("prolly-trees/cid-set");
-
-// src/blockstore/encrypt-codec.ts
-var import_multiformats = require("multiformats");
-init_utils();
-function makeCodec(ilogger, crypto2, randomBytes2) {
-  const logger = ensureLogger(ilogger, "makeCodec");
-  const enc32 = (value) => {
-    value = +value;
-    const buff = new Uint8Array(4);
-    buff[3] = value >>> 24;
-    buff[2] = value >>> 16;
-    buff[1] = value >>> 8;
-    buff[0] = value & 255;
-    return buff;
-  };
-  const readUInt32LE = (buffer) => {
-    const offset = buffer.byteLength - 4;
-    return (buffer[offset] | buffer[offset + 1] << 8 | buffer[offset + 2] << 16) + buffer[offset + 3] * 16777216;
-  };
-  const concat = (buffers) => {
-    const uint8Arrays = buffers.map((b) => b instanceof ArrayBuffer ? new Uint8Array(b) : b);
-    const totalLength = uint8Arrays.reduce((sum, arr) => sum + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const arr of uint8Arrays) {
-      result.set(arr, offset);
-      offset += arr.length;
-    }
-    return result;
-  };
-  const encode4 = ({ iv, bytes }) => concat([iv, bytes]);
-  const decode4 = (bytes) => {
-    const iv = bytes.subarray(0, 12);
-    bytes = bytes.slice(12);
-    return { iv, bytes };
-  };
-  const code = 3145728 + 1337;
-  async function subtleKey(key) {
-    return await crypto2.importKey(
-      "raw",
-      // raw or jwk
-      key,
-      // raw data
-      "AES-GCM",
-      false,
-      // extractable
-      ["encrypt", "decrypt"]
-    );
-  }
-  const decrypt = async ({ key, value }) => {
-    const { bytes: inBytes, iv } = value;
-    const cryKey = await subtleKey(key);
-    const deBytes = await crypto2.decrypt(
-      {
-        name: "AES-GCM",
-        iv,
-        tagLength: 128
-      },
-      cryKey,
-      inBytes
-    );
-    const bytes = new Uint8Array(deBytes);
-    const len = readUInt32LE(bytes.subarray(0, 4));
-    const cid = import_multiformats.CID.decode(bytes.subarray(4, 4 + len));
-    return { cid, bytes: bytes.subarray(4 + len) };
-  };
-  const encrypt = async ({ key, cid, bytes }) => {
-    const len = enc32(cid.bytes.byteLength);
-    const iv = randomBytes2(12);
-    const msg = concat([len, cid.bytes, bytes]);
-    try {
-      const cryKey = await subtleKey(key);
-      const deBytes = await crypto2.encrypt(
-        {
-          name: "AES-GCM",
-          iv,
-          tagLength: 128
-        },
-        cryKey,
-        msg
-      );
-      bytes = new Uint8Array(deBytes);
-    } catch (e) {
-      throw logger.Error().Err(e).Msg("encrypt failed").AsError();
-    }
-    return { value: { bytes, iv } };
-  };
-  const cryptoFn = (key) => {
-    return { encrypt: (opts) => encrypt({ ...opts, key }), decrypt: (opts) => decrypt({ ...opts, key }) };
-  };
-  const name = "jchris@encrypted-block:aes-gcm";
-  return { encode: encode4, decode: decode4, code, name, encrypt, decrypt, crypto: cryptoFn };
-}
-
-// src/blockstore/encrypt-helpers.ts
-function carLogIncludesGroup(list, cidMatch) {
-  return list.some((cid) => {
-    return cid.toString() === cidMatch.toString();
-  });
-}
-function makeEncDec(logger, crypto2, randomBytes2) {
-  const codec4 = makeCodec(logger, crypto2, randomBytes2);
-  const encrypt = async function* ({
-    get: get2,
-    cids,
-    hasher: hasher4,
-    key,
-    cache: cache3,
-    chunker: chunker2,
-    root: root3
-  }) {
-    const set = /* @__PURE__ */ new Set();
-    let eroot;
-    if (!carLogIncludesGroup(cids, root3)) cids.push(root3);
-    for (const cid of cids) {
-      const unencrypted = await get2(cid);
-      if (!unencrypted) throw logger.Error().Ref("cid", cid).Msg("missing cid block").AsError();
-      const encrypted = await codec4.encrypt({ ...unencrypted, key });
-      const block2 = await (0, import_block3.encode)({ ...encrypted, codec: codec4, hasher: hasher4 });
-      yield block2;
-      set.add(block2.cid.toString());
-      if (unencrypted.cid.equals(root3)) eroot = block2.cid;
-    }
-    if (!eroot) throw logger.Error().Msg("cids does not include root").AsError();
-    const list = [...set].map((s) => import_multiformats2.CID.parse(s));
-    let last;
-    for await (const node of (0, import_cid_set.create)({ list, get: get2, cache: cache3, chunker: chunker2, hasher: hasher4, codec: dagcbor })) {
-      const block2 = await node.block;
-      yield block2;
-      last = block2;
-    }
-    if (!last) throw logger.Error().Msg("missing last block").AsError();
-    const head = [eroot, last.cid];
-    const block = await (0, import_block3.encode)({ value: head, codec: dagcbor, hasher: hasher4 });
-    yield block;
-  };
-  const decrypt = async function* ({
-    root: root3,
-    get: get2,
-    key,
-    cache: cache3,
-    chunker: chunker2,
-    hasher: hasher4
-  }) {
-    const getWithDecode = async (cid) => get2(cid).then(async (block) => {
-      if (!block) return;
-      const decoded = await (0, import_block3.decode)({ ...block, codec: dagcbor, hasher: hasher4 });
-      return decoded;
-    });
-    const getWithDecrypt = async (cid) => get2(cid).then(async (block) => {
-      if (!block) return;
-      const decoded = await (0, import_block3.decode)({ ...block, codec: codec4, hasher: hasher4 });
-      return decoded;
-    });
-    const decodedRoot = await getWithDecode(root3);
-    if (!decodedRoot) throw logger.Error().Msg("missing root").AsError();
-    if (!decodedRoot.bytes) throw logger.Error().Msg("missing bytes").AsError();
-    const {
-      value: [eroot, tree]
-    } = decodedRoot;
-    const rootBlock = await get2(eroot);
-    if (!rootBlock) throw logger.Error().Msg("missing root block").AsError();
-    const cidset = await (0, import_cid_set.load)({ cid: tree, get: getWithDecode, cache: cache3, chunker: chunker2, codec: codec4, hasher: hasher4 });
-    const { result: nodes } = await cidset.getAllEntries();
-    const unwrap = async (eblock) => {
-      if (!eblock) throw logger.Error().Msg("missing block").AsError();
-      if (!eblock.value) {
-        eblock = await (0, import_block3.decode)({ ...eblock, codec: codec4, hasher: hasher4 });
-        if (!eblock.value) throw logger.Error().Msg("missing value").AsError();
-      }
-      const { bytes, cid } = await codec4.decrypt({ ...eblock, key }).catch((e) => {
-        throw e;
-      });
-      const block = await (0, import_block3.create)({ cid, bytes, hasher: hasher4, codec: codec4 });
-      return block;
-    };
-    const promises = [];
-    for (const { cid } of nodes) {
-      if (!rootBlock.cid.equals(cid)) promises.push(getWithDecrypt(cid).then(unwrap));
-    }
-    yield* promises;
-    yield unwrap(rootBlock);
-  };
-  return { encrypt, decrypt };
-}
-var chunker = (0, import_utils6.bf)(30);
-function hexStringToUint8Array(hexString) {
-  const length = hexString.length;
-  const uint8Array = new Uint8Array(length / 2);
-  for (let i = 0; i < length; i += 2) {
-    uint8Array[i / 2] = parseInt(hexString.substring(i, i + 2), 16);
-  }
-  return uint8Array;
-}
-async function encryptedEncodeCarFile(logger, crypto2, key, rootCid, t) {
-  const encryptionKey = hexStringToUint8Array(key);
-  const encryptedBlocks = new import_block4.MemoryBlockstore();
-  const cidsToEncrypt = [];
-  for (const { cid, bytes } of t.entries()) {
-    cidsToEncrypt.push(cid);
-    const g = await t.get(cid);
-    if (!g) throw logger.Error().Ref("cid", cid).Int("bytes", bytes.length).Msg("missing cid block").AsError();
-  }
-  let last = null;
-  const { encrypt } = makeEncDec(logger, crypto2, crypto2.randomBytes);
-  for await (const block of encrypt({
-    cids: cidsToEncrypt,
-    get: t.get.bind(t),
-    key: encryptionKey,
-    hasher: import_sha22.sha256,
-    chunker,
-    cache: import_cache.nocache,
-    root: rootCid
-  })) {
-    await encryptedBlocks.put(block.cid, block.bytes);
-    last = block;
-  }
-  if (!last) throw logger.Error().Msg("no blocks encrypted").AsError();
-  const encryptedCar = await encodeCarFile([last.cid], encryptedBlocks);
-  return encryptedCar;
-}
-async function decodeEncryptedCar(logger, crypto2, key, reader) {
-  const roots = await reader.getRoots();
-  const root3 = roots[0];
-  return await decodeCarBlocks(logger, crypto2, root3, reader.get.bind(reader), key);
-}
-async function decodeCarBlocks(logger, crypto2, root3, get2, keyMaterial) {
-  const decryptionKeyUint8 = hexStringToUint8Array(keyMaterial);
-  const decryptionKey = decryptionKeyUint8.buffer.slice(0, decryptionKeyUint8.byteLength);
-  const decryptedBlocks = new import_block4.MemoryBlockstore();
-  let last = null;
-  const { decrypt } = makeEncDec(logger, crypto2, crypto2.randomBytes);
-  for await (const block of decrypt({
-    root: root3,
-    get: get2,
-    key: decryptionKey,
-    hasher: import_sha22.sha256,
-    chunker,
-    cache: import_cache.nocache
-  })) {
-    await decryptedBlocks.put(block.cid, block.bytes);
-    last = block;
-  }
-  if (!last) throw logger.Error().Msg("no blocks decrypted").AsError();
-  return { blocks: decryptedBlocks, root: last.cid };
-}
-
 // src/blockstore/transaction.ts
-var import_block5 = require("@web3-storage/pail/block");
-init_types();
-init_crypto();
+var import_block3 = require("@web3-storage/pail/block");
+var import_cement2 = require("@adviser/cement");
 init_utils();
-var CarTransaction = class extends import_block5.MemoryBlockstore {
-  constructor(parent, opts = { add: true }) {
+var CarTransaction = class extends import_block3.MemoryBlockstore {
+  constructor(parent, opts = { add: true, noLoader: false }) {
     super();
     if (opts.add) {
       parent.transactions.add(this);
@@ -1592,8 +1176,8 @@ var CarTransaction = class extends import_block5.MemoryBlockstore {
     return super.get(cid);
   }
 };
-function defaultedBlockstoreRuntime(opts, component, ctx) {
-  const logger = ensureLogger(opts, component, ctx);
+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
@@ -1610,22 +1194,24 @@ function defaultedBlockstoreRuntime(opts, component, ctx) {
     threshold: 1e3 * 1e3,
     ...opts,
     logger,
-    crypto: toCryptoOpts(opts.crypto),
+    keyBag: opts.keyBag || {},
+    crypto: (0, import_cement2.toCryptoRuntime)(opts.crypto),
     store,
-    storeRuntime: toStoreRuntime(store, logger)
+    storeRuntime: toStoreRuntime(store, sthis)
   };
 }
-var blockstoreFactory = function(opts) {
+function blockstoreFactory(sthis, opts) {
   if (opts.name) {
-    return new EncryptedBlockstore(opts);
+    return new EncryptedBlockstore(sthis, opts);
   } else {
     return new BaseBlockstore(opts);
   }
-};
+}
 var BaseBlockstore = class {
   constructor(ebOpts = {}) {
     this.transactions = /* @__PURE__ */ new Set();
-    this.ebOpts = defaultedBlockstoreRuntime(ebOpts, "BaseBlockstore");
+    this.sthis = ensureSuperThis(ebOpts);
+    this.ebOpts = defaultedBlockstoreRuntime(this.sthis, ebOpts, "BaseBlockstore");
     this.logger = this.ebOpts.logger;
   }
   // ready: Promise<void>;
@@ -1648,8 +1234,8 @@ var BaseBlockstore = class {
     throw this.logger.Error().Msg("use a transaction to put").AsError();
   }
   // TransactionMeta
-  async transaction(fn, _opts = {}) {
-    const t = new CarTransaction(this);
+  async transaction(fn, _opts) {
+    const t = new CarTransaction(this, _opts);
     const done = await fn(t);
     this.lastTxMeta = done;
     return { t, meta: done };
@@ -1666,16 +1252,16 @@ var BaseBlockstore = class {
   }
 };
 var EncryptedBlockstore = class extends BaseBlockstore {
-  constructor(ebOpts) {
+  constructor(sthis, ebOpts) {
     super(ebOpts);
     this.compacting = false;
-    this.logger = ensureLogger(ebOpts, "EncryptedBlockstore");
+    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);
+    this.loader = new Loader(this.name, ebOpts, sthis);
   }
   ready() {
     return this.loader.ready();
@@ -1706,10 +1292,13 @@ var EncryptedBlockstore = class extends BaseBlockstore {
     }
     throw this.logger.Error().Msg("failed to commit car files").AsError();
   }
-  async getFile(car, cid, isPublic = false) {
+  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 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;
@@ -1765,43 +1354,345 @@ var CompactionFetcher = class {
 };
 
 // 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();
+  }
+  async enqueue(fn) {
+    return new Promise((resolve, reject) => {
+      const queueFn = async () => {
+        try {
+          resolve(await fn());
+        } catch (e) {
+          reject(e);
+        } finally {
+          this.processing = false;
+          this.processNext();
+        }
+      };
+      this.queue.push(queueFn);
+      if (!this.processing) {
+        this.processNext();
+      }
+    });
+  }
+  processNext() {
+    if (this.queue.length > 0 && !this.processing) {
+      this.processing = true;
+      const queueFn = this.queue.shift();
+      if (queueFn) {
+        queueFn().finally(() => {
+        });
+      }
+    }
+    if (this.queue.length === 0 && !this.processing) {
+      const toResolve = Array.from(this._waitIdleItems);
+      this._waitIdleItems.clear();
+      toResolve.map((fn) => fn.resolve());
+    }
+  }
+};
+
+// src/runtime/key-bag.ts
+var key_bag_exports = {};
+__export(key_bag_exports, {
+  KeyBag: () => KeyBag,
+  getKeyBag: () => getKeyBag,
+  registerKeyBagProviderFactory: () => registerKeyBagProviderFactory
+});
+var import_cement5 = require("@adviser/cement");
+init_utils();
+var import_base582 = require("multiformats/bases/base58");
+var KeyBag = class {
+  constructor(rt) {
+    this.rt = rt;
+    this._seq = new import_cement5.ResolveSeq();
+    this.logger = ensureLogger(rt.sthis, "KeyBag", {
+      id: rt.id()
+    });
+    this.logger.Debug().Msg("KeyBag created");
+  }
+  async subtleKey(key) {
+    return await this.rt.crypto.importKey(
+      "raw",
+      // raw or jwk
+      import_base582.base58btc.decode(key),
+      // hexStringToUint8Array(key), // raw data
+      "AES-GCM",
+      false,
+      // extractable
+      ["encrypt", "decrypt"]
+    );
+  }
+  async ensureKeyFromUrl(url, keyFactory) {
+    const storeKey = url.getParam("storekey");
+    if (storeKey === "insecure") {
+      return import_cement5.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_cement5.Result.Ok(urb.URI());
+    }
+    if (storeKey.startsWith("@") && storeKey.endsWith("@")) {
+      const ret = await this.getNamedKey(storeKey);
+      if (ret.isErr()) {
+        return ret;
+      }
+    }
+    return import_cement5.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_cement5.Result.Ok({
+      key,
+      fingerPrint: import_base582.base58btc.encode(new Uint8Array(fpr))
+    });
+  }
+  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 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_cement5.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;
+    });
+  }
+};
+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;
+  }
+  const logger = ensureLogger(sthis, "KeyBag");
+  let url;
+  if (kbo.url) {
+    url = import_cement5.URI.from(kbo.url);
+    logger.Debug().Url(url).Msg("from opts");
+  } else {
+    let bagFnameOrUrl = sthis.env.get("FP_KEYBAG_URL");
+    if ((0, import_cement5.runtimeFn)().isBrowser) {
+      url = import_cement5.URI.from(bagFnameOrUrl || "indexdb://fp-keybag");
+    } else {
+      if (!bagFnameOrUrl) {
+        const home = sthis.env.get("HOME");
+        bagFnameOrUrl = `${home}/.fireproof/keybag`;
+        url = import_cement5.URI.from(`file://${bagFnameOrUrl}`);
+      } else {
+        url = import_cement5.URI.from(bagFnameOrUrl);
+      }
+    }
+    logger.Debug().Url(url).Msg("from env");
+  }
+  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;
+    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_cement5.toCryptoRuntime)({}),
+    sthis,
+    logger,
+    keyLength: kbo.keyLength || 16,
+    getBag: keyProviderFactory,
+    id: () => {
+      return url.toString();
+    }
+  };
+}
+var _keyBags = new import_cement5.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 });
+  }
+  const buffer = new Uint8Array(size);
+  const writer = CBW.createWriter(buffer, { headerSize });
+  for (const r of roots) {
+    writer.addRoot(r);
   }
-  async enqueue(fn) {
-    return new Promise((resolve, reject) => {
-      const queueFn = async () => {
-        try {
-          resolve(await fn());
-        } catch (e) {
-          reject(e);
-        } finally {
-          this.processing = false;
-          this.processNext();
-        }
-      };
-      this.queue.push(queueFn);
-      if (!this.processing) {
-        this.processNext();
-      }
-    });
+  for (const { cid, bytes } of t.entries()) {
+    writer.write({ cid, bytes });
   }
-  processNext() {
-    if (this.queue.length > 0 && !this.processing) {
-      this.processing = true;
-      const queueFn = this.queue.shift();
-      if (queueFn) {
-        queueFn();
-      }
+  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);
+  }
+  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);
     }
   }
-};
+  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
+  });
+}
+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);
+  }
+  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 || 1e3 * 1e3;
+  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 CBW2 = __toESM(require("@ipld/car/buffer-writer"), 1);
-function carLogIncludesGroup2(list, cids) {
+var import_sha23 = require("multiformats/hashes/sha2");
+function carLogIncludesGroup(list, cids) {
   return list.some((arr) => {
     return arr.toString() === cids.toString();
   });
@@ -1814,17 +1705,8 @@ function uniqueCids(list, remove = /* @__PURE__ */ new Set()) {
   }
   return [...byString.values()];
 }
-function toHexString(byteArray) {
-  return Array.from(byteArray).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-var Loadable = class {
-  constructor() {
-    this.name = "";
-    this.carLog = new Array();
-  }
-};
 var Loader = class {
-  constructor(name, ebOpts) {
+  constructor(name, ebOpts, sthis) {
     this.commitQueue = new CommitQueue();
     this.isCompacting = false;
     this.carReaders = /* @__PURE__ */ new Map();
@@ -1834,9 +1716,11 @@ var Loader = class {
     this.getBlockCache = /* @__PURE__ */ new Map();
     this.seenMeta = /* @__PURE__ */ new Set();
     this.writeLimit = (0, import_p_limit.default)(1);
-    this.onceReady = new import_cement4.ResolveOnce();
+    this.onceReady = new import_cement6.ResolveOnce();
     this.name = name;
+    this.sthis = sthis;
     this.ebOpts = defaultedBlockstoreRuntime(
+      sthis,
       {
         ...ebOpts,
         name
@@ -1846,14 +1730,17 @@ var Loader = class {
     this.logger = this.ebOpts.logger;
   }
   // readonly id = uuidv4();
+  async keyBag() {
+    return getKeyBag(this.sthis, this.ebOpts.keyBag);
+  }
   async carStore() {
     return this.ebOpts.storeRuntime.makeDataStore(this);
   }
   async fileStore() {
     return this.ebOpts.storeRuntime.makeDataStore(this);
   }
-  async remoteWAL() {
-    return this.ebOpts.storeRuntime.makeRemoteWAL(this);
+  async WALStore() {
+    return this.ebOpts.storeRuntime.makeWALStore(this);
   }
   async metaStore() {
     return this.ebOpts.storeRuntime.makeMetaStore(this);
@@ -1867,11 +1754,11 @@ var Loader = class {
     });
   }
   async close() {
-    const toClose = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.remoteWAL()]);
+    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.remoteWAL()]);
+    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) {
@@ -1885,6 +1772,7 @@ var Loader = class {
   //   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);
@@ -1897,10 +1785,7 @@ var Loader = class {
     }
     if (this.seenMeta.has(meta.cars.toString())) return;
     this.seenMeta.add(meta.cars.toString());
-    if (meta.key) {
-      await this.setKey(meta.key);
-    }
-    if (carLogIncludesGroup2(this.carLog, meta.cars)) {
+    if (carLogIncludesGroup(this.carLog, meta.cars)) {
       return;
     }
     const carHeader = await this.loadCarHeaderFromMeta(meta);
@@ -1909,45 +1794,59 @@ var Loader = class {
     this.carLog = [...uniqueCids([meta.cars, ...this.carLog, ...carHeader.cars], this.seenCompacted)];
     await this.ebOpts.applyMeta?.(carHeader.meta);
   }
-  async ingestKeyFromMeta(meta) {
-    const { key } = meta;
-    if (key) {
-      await this.setKey(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 _getKey() {
-    if (this.key) return this.key;
-    if (!this.ebOpts.public) {
-      await this.setKey(toHexString(this.ebOpts.crypto.randomBytes(32)));
-    }
-    return this.key || void 0;
-  }
-  async commitFiles(t, done, opts = { noLoader: false, compact: false }) {
-    return this.commitQueue.enqueue(() => this._commitInternalFiles(t, done, opts));
-  }
-  // can these skip the queue? or have a file queue?
-  async _commitInternalFiles(t, done, opts = { noLoader: false, compact: false }) {
+  // 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 { files: roots } = this.makeFileCarHeader(done);
-    const cids = [];
-    const cars = await this.prepareCarFilesFiles(roots, t, !!opts.public);
-    for (const car of cars) {
-      const { cid, bytes } = car;
-      await (await this.fileStore()).save({ cid, bytes });
-      await (await this.remoteWAL()).enqueueFile(cid, !!opts.public);
-      cids.push(cid);
-    }
-    return cids;
+    const fstore = await this.fileStore();
+    const wstore = await this.WALStore();
+    return this.commitQueue.enqueue(() => commitFiles(fstore, wstore, t, done));
   }
-  async loadFileCar(cid, isPublic = false) {
-    return await this.storesLoadCar(cid, await this.fileStore(), this.remoteFileStore, isPublic);
+  async loadFileCar(cid) {
+    return await this.storesLoadCar(cid, await this.fileStore(), this.remoteFileStore);
   }
   async commit(t, done, opts = { noLoader: false, compact: false }) {
-    return this.commitQueue.enqueue(() => this._commitInternal(t, done, opts));
+    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()
+    };
+    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 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 cacheTransaction(t) {
     for await (const block of t.entries()) {
@@ -1967,79 +1866,6 @@ var Loader = class {
       }
     }
   }
-  async _commitInternal(t, done, opts = { noLoader: false, compact: false }) {
-    await this.ready();
-    const fp = this.makeCarHeader(done, this.carLog, !!opts.compact);
-    const rootBlock = await encodeCarHeader(fp);
-    const cars = await this.prepareCarFiles(rootBlock, t, !!opts.public);
-    const cids = [];
-    for (const car of cars) {
-      const { cid, bytes } = car;
-      await (await this.carStore()).save({ cid, bytes });
-      cids.push(cid);
-    }
-    await this.cacheTransaction(t);
-    const newDbMeta = { cars: cids, key: this.key || null };
-    await (await this.remoteWAL()).enqueue(newDbMeta, opts);
-    await (await this.metaStore()).save(newDbMeta);
-    await this.updateCarLog(cids, fp, !!opts.compact);
-    return cids;
-  }
-  async prepareCarFilesFiles(roots, t, isPublic) {
-    const theKey = isPublic ? null : await this._getKey();
-    const car = theKey && this.ebOpts.crypto ? await encryptedEncodeCarFile(this.logger, this.ebOpts.crypto, theKey, roots[0], t) : await encodeCarFile(roots, t);
-    return [car];
-  }
-  async prepareCarFiles(rootBlock, t, isPublic) {
-    const theKey = isPublic ? void 0 : await this._getKey();
-    const carFiles = [];
-    const threshold = this.ebOpts.threshold || 1e3 * 1e3;
-    let clonedt = new CarTransaction(t.parent, { add: false });
-    clonedt.putSync(rootBlock.cid, rootBlock.bytes);
-    let newsize = CBW2.blockLength(toCIDBlock(rootBlock));
-    let cidRootBlock = rootBlock;
-    for (const { cid, bytes } of t.entries()) {
-      newsize += CBW2.blockLength(toCIDBlock({ cid, bytes }));
-      if (newsize >= threshold) {
-        carFiles.push(await this.createCarFile(theKey, cidRootBlock.cid, clonedt));
-        clonedt = new CarTransaction(t.parent, { add: false });
-        clonedt.putSync(cid, bytes);
-        cidRootBlock = { cid, bytes };
-        newsize = CBW2.blockLength(toCIDBlock({ cid, bytes }));
-      } else {
-        clonedt.putSync(cid, bytes);
-      }
-    }
-    carFiles.push(await this.createCarFile(theKey, cidRootBlock.cid, clonedt));
-    return carFiles;
-  }
-  async createCarFile(theKey, cid, t) {
-    try {
-      return theKey && this.ebOpts.crypto ? await encryptedEncodeCarFile(this.logger, this.ebOpts.crypto, theKey, cid, t) : await encodeCarFile([cid], t);
-    } catch (e) {
-      console.error("error creating car file", e);
-      throw e;
-    }
-  }
-  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);
-      }
-    }
-    return { ...result, files };
-  }
-  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]);
-    } else {
-      this.carLog.unshift(cids);
-    }
-  }
   async removeCidsForCompact(cid) {
     const carHeader = await this.loadCarHeaderFromMeta({
       cars: [cid]
@@ -2058,9 +1884,9 @@ var Loader = class {
   //     await this.remoteWAL!.enqueue(dbMeta, { public: false })
   //   }
   // }
-  async *entries(cache3 = true) {
+  async *entries(cache2 = true) {
     await this.ready();
-    if (cache3) {
+    if (cache2) {
       for (const [, block] of this.getBlockCache) {
         yield block;
       }
@@ -2142,10 +1968,6 @@ var Loader = class {
     }
     return got;
   }
-  makeCarHeader(meta, cars, compact = false) {
-    const coreHeader = compact ? { cars: [], compact: cars } : { cars, compact: [] };
-    return { ...coreHeader, meta };
-  }
   async loadCar(cid) {
     if (!this.carStore) {
       throw this.logger.Error().Msg("car store not initialized").AsError();
@@ -2153,72 +1975,52 @@ var Loader = class {
     const loaded = await this.storesLoadCar(cid, await this.carStore(), this.remoteCarStore);
     return loaded;
   }
-  //What if instead it returns an Array of CarHeader
-  async storesLoadCar(cid, local, remote, publicFiles) {
+  async makeDecoderAndCarReader(cid, local, remote) {
     const cidsString = cid.toString();
-    if (!this.carReaders.has(cidsString)) {
-      this.carReaders.set(
-        cidsString,
-        (async () => {
-          let loadedCar = void 0;
-          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;
-              }
-            } else {
-              this.logger.Error().Str("cid", cidsString).Err(e).Msg("loading car");
-            }
-          }
-          if (!loadedCar) {
-            throw this.logger.Error().Url(local.url).Str("cid", cidsString).Msg("missing car files").AsError();
-          }
-          const rawReader = await import_car.CarReader.fromBytes(loadedCar.bytes);
-          const readerP = publicFiles ? Promise.resolve(rawReader) : this.ensureDecryptedReader(rawReader);
-          const cachedReaderP = readerP.then(async (reader) => {
-            await this.cacheCarReader(cidsString, reader).catch(() => {
-              return;
-            });
-            return reader;
-          });
-          this.carReaders.set(cidsString, cachedReaderP);
-          return readerP;
-        })().catch((e) => {
-          this.carReaders.delete(cidsString);
-          throw e;
-        })
-      );
+    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");
+      }
     }
-    return this.carReaders.get(cidsString);
-  }
-  async ensureDecryptedReader(reader) {
-    const theKey = await this._getKey();
-    if (this.ebOpts.public || !(theKey && this.ebOpts.crypto)) {
-      return reader;
+    if (!loadedCar) {
+      throw this.logger.Error().Url(local.url()).Str("cid", cidsString).Msg("missing car files").AsError();
     }
-    const { blocks, root: root3 } = await decodeEncryptedCar(this.logger, this.ebOpts.crypto, theKey, reader);
-    return {
-      getRoots: () => [root3],
-      get: blocks.get.bind(blocks),
-      blocks: blocks.entries.bind(blocks)
-    };
+    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;
   }
-  async setKey(key) {
-    if (this.key && this.key !== key)
-      throw this.logger.Error().Str("this.key", this.key).Str("key", key).Msg("setting key").AsError();
-    this.key = key;
-    const encoder = new TextEncoder();
-    const data = encoder.encode(key);
-    const hashBuffer = await this.ebOpts.crypto.digestSHA256(data);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    this.keyId = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  //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);
+    }
+    return dacr;
   }
   async getMoreReaders(cids) {
     const limit = (0, import_p_limit.default)(5);
@@ -2227,20 +2029,345 @@ var Loader = class {
   }
 };
 
+// src/runtime/keyed-crypto.ts
+var keyed_crypto_exports = {};
+__export(keyed_crypto_exports, {
+  BlockIvKeyIdCodec: () => BlockIvKeyIdCodec,
+  keyedCryptoFactory: () => keyedCryptoFactory
+});
+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: {
+    // 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;
+    }
+  },
+  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 * 8);
+      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") !== "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 || {};
+  }
+  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 })
+    });
+  }
+  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_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();
+    }
+    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;
+  }
+};
+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
+    };
+  }
+  async _decrypt(data) {
+    this.logger.Debug().Len(data.bytes).Str("fp", this.key.fingerPrint).Msg("decrypting");
+    return new Uint8Array(await this.crypto.decrypt(this.algo(data.iv), this.key.key, data.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));
+  }
+};
+var nullCodec = class {
+  constructor() {
+    this.code = 0;
+    this.name = "Fireproof@unencrypted-block";
+  }
+  encode(data) {
+    return data;
+  }
+  decode(data) {
+    return data;
+  }
+};
+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;
+  }
+  fingerPrint() {
+    return Promise.resolve(this._fingerPrint);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  codec(iv) {
+    return new nullCodec();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  algo(iv) {
+    return {
+      name: "noCrypto",
+      iv: new Uint8Array(),
+      tagLength: 0
+    };
+  }
+  _decrypt() {
+    throw this.logger.Error().Msg("noCrypto.decrypt not implemented").AsError();
+  }
+  _encrypt() {
+    throw this.logger.Error().Msg("noCrypto.decrypt not implemented").AsError();
+  }
+};
+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();
+      }
+    }
+    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_base584 = require("multiformats/bases/base58");
+var import_cborg = require("cborg");
+function getFragSize(url) {
+  const fragSize = url.getParam("fragSize");
+  let ret = 0;
+  if (fragSize) {
+    ret = parseInt(fragSize);
+  }
+  if (isNaN(ret) || ret <= 0) {
+    ret = 0;
+  }
+  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];
+    }
+    const data = res.unwrap();
+    return [
+      import_cement.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_cement.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_cement.Result.Err(logger.Error().Msg("Fragment fid mismatch").AsError());
+        }
+        if (fragment.ofs !== ofs2) {
+          return import_cement.Result.Err(logger.Error().Uint64("ofs", ofs2).Msg("Fragment ofs mismatch").AsError());
+        }
+        return import_cement.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();
+    }
+    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));
+    }
+    return ops;
+  }
+  buildUrl(baseUrl, key) {
+    return this.innerGW.buildUrl(baseUrl, key);
+  }
+  async destroy(iurl) {
+    return this.innerGW.destroy(iurl);
+  }
+  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 close(url) {
+    return this.innerGW.close(url);
+  }
+  async put(url, body) {
+    await Promise.all(this.slicer(url, body));
+    return import_cement.Result.Ok(void 0);
+  }
+  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_cement.Result.Err(rfrag.Err());
+      }
+      const frag = rfrag.Ok();
+      buffer = buffer || new Uint8Array(frag.len);
+      buffer.set(frag.data, frag.ofs);
+    }
+    return import_cement.Result.Ok(buffer || new Uint8Array(0));
+  }
+  async delete(url) {
+    const rfrags = await getFrags(url, this.innerGW, this.headerSize, this.logger);
+    for (const rfrag of rfrags) {
+      if (rfrag.isErr()) {
+        return import_cement.Result.Err(rfrag.Err());
+      }
+      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);
+    }
+    return import_cement.Result.Ok(void 0);
+  }
+};
+
 // src/blockstore/store.ts
-function guardVersion(url2) {
-  if (!url2.searchParams.has("version")) {
-    return import_cement5.Result.Err(`missing version: ${url2.toString()}`);
+function guardVersion(url) {
+  if (!url.hasParam("version")) {
+    return import_cement7.Result.Err(`missing version: ${url.toString()}`);
   }
-  return import_cement5.Result.Ok(url2);
+  return import_cement7.Result.Ok(url);
 }
-var VersionedStore = class {
-  constructor(name, url2, logger) {
+var BaseStoreImpl = class {
+  constructor(name, url, opts, sthis, logger) {
     this._onStarted = [];
     this._onClosed = [];
     this.name = name;
-    this.url = url2;
-    this.logger = logger;
+    this._url = url;
+    this.keybag = opts.keybag;
+    this.sthis = sthis;
+    this.logger = logger.With().Ref("url", () => this._url.toString()).Str("name", name).Logger();
+    this.gateway = new FragmentGateway(this.sthis, opts.gateway);
+  }
+  url() {
+    return this._url;
   }
   onStarted(fn) {
     this._onStarted.push(fn);
@@ -2248,110 +2375,168 @@ var VersionedStore = class {
   onClosed(fn) {
     this._onClosed.push(fn);
   }
+  async keyedCrypto() {
+    return keyedCryptoFactory(this._url, await 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();
+    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 skRes = await kb.ensureKeyFromUrl(this._url, () => {
+      const idx = this._url.getParam("index");
+      const storeKeyName = [this.name];
+      if (idx) {
+        storeKeyName.push(idx);
+      }
+      storeKeyName.push(this.storeType);
+      return storeKeyName.join(":");
+    });
+    if (skRes.isErr()) {
+      return skRes;
+    }
+    this._url = skRes.Ok();
+    const version = guardVersion(this._url);
+    if (version.isErr()) {
+      this.logger.Error().Result("version", version).Msg("guardVersion");
+      await this.close();
+      return version;
+    }
+    if (this.ready) {
+      const fn = this.ready.bind(this);
+      const ready = await exception2Result(fn);
+      if (ready.isErr()) {
+        await this.close();
+        return ready;
+      }
+    }
+    this._onStarted.forEach((fn) => fn());
+    this.logger.Debug().Msg("started");
+    return version;
+  }
 };
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
-var MetaStore = class extends VersionedStore {
-  constructor(name, url2, logger, gateway) {
-    super(name, url2, ensureLogger(logger, "MetaStore", {}));
-    this.tag = "header-base";
-    this.gateway = gateway;
-  }
-  makeHeader({ cars, key }) {
+var MetaStoreImpl = class extends BaseStoreImpl {
+  constructor(sthis, name, url, opts) {
+    super(
+      name,
+      url,
+      {
+        ...opts
+      },
+      sthis,
+      ensureLogger(sthis, "MetaStoreImpl")
+    );
+    this.storeType = "meta";
+    this.subscribers = /* @__PURE__ */ new Map();
+  }
+  onLoad(branch, loadHandler) {
+    const subscribers = this.subscribers.get(branch) || [];
+    subscribers.push(loadHandler);
+    this.subscribers.set(branch, subscribers);
+    return () => {
+      const subscribers2 = this.subscribers.get(branch) || [];
+      const idx = subscribers2.indexOf(loadHandler);
+      if (idx > -1) subscribers2.splice(idx, 1);
+    };
+  }
+  makeHeader({ cars }) {
     const toEncode = { cars };
-    if (key) toEncode.key = key;
     return (0, import_dag_json.format)(toEncode);
   }
   parseHeader(headerData) {
     const got = (0, import_dag_json.parse)(headerData);
     return got;
   }
-  async start() {
-    this.logger.Debug().Msg("starting");
-    const res = await this.gateway.start(this.url);
-    if (res.isErr()) {
-      return res;
+  async handleSubscribers(dbMetas, branch) {
+    try {
+      const subscribers = this.subscribers.get(branch) || [];
+      await Promise.all(subscribers.map((subscriber) => subscriber(dbMetas)));
+    } catch (e) {
+      this.logger.Error().Err(e).Msg("handleSubscribers").AsError();
     }
-    this._onStarted.forEach((fn) => fn());
-    return guardVersion(this.url);
+  }
+  async handleByteHeads(byteHeads, branch = "main") {
+    let dbMetas;
+    try {
+      dbMetas = this.dbMetasForByteHeads(byteHeads);
+    } catch (e) {
+      throw this.logger.Error().Err(e).Msg("parseHeader").AsError();
+    }
+    await this.handleSubscribers(dbMetas, branch);
+    return dbMetas;
+  }
+  dbMetasForByteHeads(byteHeads) {
+    return byteHeads.map((bytes) => {
+      const txt = this.sthis.txt.decode(bytes);
+      return this.parseHeader(txt);
+    });
   }
   async load(branch) {
-    this.logger.Debug().Str("branch", branch || "").Msg("loading");
-    const url2 = await this.gateway.buildUrl(this.url, branch || "main");
-    if (url2.isErr()) {
-      throw this.logger.Error().Result("buidUrl", url2).Str("branch", branch || "").Url(this.url).Msg("got error from gateway.buildUrl").AsError();
+    branch = branch || "main";
+    this.logger.Debug().Str("branch", branch).Msg("loading");
+    const url = await this.gateway.buildUrl(this.url(), branch);
+    if (url.isErr()) {
+      throw this.logger.Error().Result("buidUrl", url).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
     }
-    const bytes = await this.gateway.get(url2.Ok());
+    const bytes = await this.gateway.get(url.Ok());
     if (bytes.isErr()) {
       if (isNotFoundError(bytes)) {
         return void 0;
       }
-      throw this.logger.Error().Url(url2.Ok()).Result("bytes:", bytes).Msg("gateway get").AsError();
-    }
-    try {
-      return [this.parseHeader(textDecoder.decode(bytes.Ok()))];
-    } catch (e) {
-      throw this.logger.Error().Err(e).Msg("parseHeader").AsError();
+      throw this.logger.Error().Url(url.Ok()).Result("bytes:", bytes).Msg("gateway get").AsError();
     }
+    return this.handleByteHeads([bytes.Ok()], branch);
   }
-  async save(meta, branch = "main") {
+  async save(meta, branch) {
+    branch = branch || "main";
     this.logger.Debug().Str("branch", branch).Any("meta", meta).Msg("saving meta");
     const bytes = this.makeHeader(meta);
-    const url2 = await this.gateway.buildUrl(this.url, branch);
-    if (url2.isErr()) {
-      throw this.logger.Error().Err(url2.Err()).Str("branch", branch).Url(this.url).Msg("got error from gateway.buildUrl").AsError();
+    const url = await this.gateway.buildUrl(this.url(), branch);
+    if (url.isErr()) {
+      throw this.logger.Error().Err(url.Err()).Str("branch", branch).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.put(url2.Ok(), textEncoder.encode(bytes));
+    const res = await this.gateway.put(url.Ok(), this.sthis.txt.encode(bytes));
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
     }
-    return res.Ok();
+    await this.handleSubscribers([meta], branch);
+    return res;
   }
   async close() {
-    await this.gateway.close(this.url);
+    await this.gateway.close(this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement5.Result.Ok(void 0);
+    return import_cement7.Result.Ok(void 0);
   }
   async destroy() {
-    return this.gateway.destroy(this.url);
+    return this.gateway.destroy(this.url());
   }
 };
-var DataStore = class extends VersionedStore {
-  constructor(name, url2, logger, gateway) {
+var DataStoreImpl = class extends BaseStoreImpl {
+  // readonly tag: string = "car-base";
+  constructor(sthis, name, url, opts) {
     super(
       name,
-      url2,
-      ensureLogger(logger, "DataStore", {
-        url: () => url2.toString()
-      })
+      url,
+      {
+        ...opts
+      },
+      sthis,
+      ensureLogger(sthis, "DataStoreImpl")
     );
-    this.tag = "car-base";
-    this.gateway = gateway;
-  }
-  async start() {
-    this.logger.Debug().Msg("starting-gateway");
-    const res = await this.gateway.start(this.url);
-    if (res.isErr()) {
-      this.logger.Error().Result("gw-start", res).Msg("started-gateway");
-      return res;
-    }
-    this._onStarted.forEach((fn) => fn());
-    const version = guardVersion(this.url);
-    if (version.isErr()) {
-      this.logger.Error().Result("version", version).Msg("guardVersion");
-      await this.close();
-      return version;
-    }
-    this.logger.Debug().Msg("started");
-    return version;
+    this.storeType = "data";
   }
   async load(cid) {
     this.logger.Debug().Any("cid", cid).Msg("loading");
-    const url2 = await this.gateway.buildUrl(this.url, cid.toString());
-    if (url2.isErr()) {
-      throw this.logger.Error().Err(url2.Err()).Str("cid", cid.toString()).Msg("got error from gateway.buildUrl").AsError();
+    const url = await this.gateway.buildUrl(this.url(), cid.toString());
+    if (url.isErr()) {
+      throw this.logger.Error().Err(url.Err()).Str("cid", cid.toString()).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.get(url2.Ok());
+    const res = await this.gateway.get(url.Ok());
     if (res.isErr()) {
       throw res.Err();
     }
@@ -2360,57 +2545,64 @@ var DataStore = class extends VersionedStore {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async save(car, opts) {
     this.logger.Debug().Any("cid", car.cid.toString()).Msg("saving");
-    const url2 = await this.gateway.buildUrl(this.url, car.cid.toString());
-    if (url2.isErr()) {
-      throw this.logger.Error().Err(url2.Err()).Ref("cid", car.cid).Msg("got error from gateway.buildUrl").AsError();
+    const url = await this.gateway.buildUrl(this.url(), car.cid.toString());
+    if (url.isErr()) {
+      throw this.logger.Error().Err(url.Err()).Ref("cid", car.cid).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.put(url2.Ok(), car.bytes);
+    const res = await this.gateway.put(url.Ok(), car.bytes);
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
     }
     return res.Ok();
   }
   async remove(cid) {
-    const url2 = await this.gateway.buildUrl(this.url, cid.toString());
-    if (url2.isErr()) {
-      return url2;
+    const url = await this.gateway.buildUrl(this.url(), cid.toString());
+    if (url.isErr()) {
+      return url;
     }
-    return this.gateway.delete(url2.Ok());
+    return this.gateway.delete(url.Ok());
   }
   async close() {
-    await this.gateway.close(this.url);
+    await this.gateway.close(this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement5.Result.Ok(void 0);
+    return import_cement7.Result.Ok(void 0);
   }
   destroy() {
-    return this.gateway.destroy(this.url);
+    return this.gateway.destroy(this.url());
   }
 };
-var RemoteWAL = class extends VersionedStore {
-  constructor(loader, url2, logger, gateway) {
-    super(loader.name, url2, ensureLogger(logger, "RemoteWAL"));
-    this.tag = "rwal-base";
-    this._ready = new import_cement5.ResolveOnce();
+var WALStoreImpl = class extends BaseStoreImpl {
+  constructor(loader, url, opts) {
+    super(
+      loader.name,
+      url,
+      {
+        ...opts
+      },
+      loader.sthis,
+      ensureLogger(loader.sthis, "WALStoreImpl")
+    );
+    this.storeType = "wal";
+    this._ready = new import_cement7.ResolveOnce();
     this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
     this.processing = void 0;
     this.processQueue = new CommitQueue();
-    this.loader = loader;
-    this.gateway = gateway;
-  }
-  async ready() {
-    return this._ready.once(async () => {
-      const walState = await this.load().catch((e) => {
-        this.logger.Error().Any("error", e).Msg("error loading wal");
-        return void 0;
+    this.ready = async () => {
+      return this._ready.once(async () => {
+        const walState = await this.load().catch((e) => {
+          this.logger.Error().Any("error", e).Msg("error loading wal");
+          return void 0;
+        });
+        if (!walState) {
+          this.walState.operations = [];
+          this.walState.fileOperations = [];
+        } else {
+          this.walState.operations = walState.operations || [];
+          this.walState.fileOperations = walState.fileOperations || [];
+        }
       });
-      if (!walState) {
-        this.walState.operations = [];
-        this.walState.fileOperations = [];
-      } else {
-        this.walState.operations = walState.operations || [];
-        this.walState.fileOperations = walState.fileOperations || [];
-      }
-    });
+    };
+    this.loader = loader;
   }
   async enqueue(dbMeta, opts) {
     await this.ready();
@@ -2420,19 +2612,23 @@ var RemoteWAL = class extends VersionedStore {
       this.walState.operations.push(dbMeta);
     }
     await this.save(this.walState);
-    void this._process();
+    void this.process();
   }
   async enqueueFile(fileCid, publicFile = false) {
     await this.ready();
     this.walState.fileOperations.push({ cid: fileCid, public: publicFile });
   }
-  async _process() {
+  async process() {
     await this.ready();
     if (!this.loader.remoteCarStore) return;
     await this.processQueue.enqueue(async () => {
-      await this._doProcess();
+      try {
+        await this._doProcess();
+      } catch (e) {
+        this.logger.Error().Any("error", e).Msg("error processing wal");
+      }
       if (this.walState.operations.length || this.walState.fileOperations.length || this.walState.noLoaderOps.length) {
-        setTimeout(() => void this._process(), 0);
+        setTimeout(() => void this.process(), 0);
       }
     });
   }
@@ -2450,7 +2646,7 @@ var RemoteWAL = class extends VersionedStore {
           for (const cid of dbMeta.cars) {
             const car = await (await this.loader.carStore()).load(cid);
             if (!car) {
-              if (carLogIncludesGroup2(this.loader.carLog, dbMeta.cars))
+              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);
@@ -2465,7 +2661,7 @@ var RemoteWAL = class extends VersionedStore {
           for (const cid of dbMeta.cars) {
             const car = await (await this.loader.carStore()).load(cid).catch(() => null);
             if (!car) {
-              if (carLogIncludesGroup2(this.loader.carLog, dbMeta.cars))
+              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);
@@ -2490,11 +2686,7 @@ var RemoteWAL = class extends VersionedStore {
         const res = await Promise.allSettled(uploads);
         const errors = res.filter((r) => r.status === "rejected");
         if (errors.length) {
-          throw this.logger.Error().Any(
-            "errors",
-            errors.map((e) => e.reason)
-          ).Msg("error uploading").AsError();
-          errors[0].reason;
+          throw this.logger.Error().Any("errors", errors).Msg("error uploading").AsError();
         }
         if (operations.length) {
           const lastOp = operations[operations.length - 1];
@@ -2509,29 +2701,11 @@ var RemoteWAL = class extends VersionedStore {
     })();
     await rmlp;
   }
-  async start() {
-    const res = await this.gateway.start(this.url);
-    if (res.isErr()) {
-      return res;
-    }
-    const ver = guardVersion(this.url);
-    if (ver.isErr()) {
-      await this.close();
-      return ver;
-    }
-    const ready = await exception2Result(() => this.ready());
-    this._onStarted.forEach((fn) => fn());
-    if (ready.isErr()) {
-      await this.close();
-      return ready;
-    }
-    return ready;
-  }
   async load() {
     this.logger.Debug().Msg("loading");
-    const filepath = await this.gateway.buildUrl(this.url, "main");
+    const filepath = await this.gateway.buildUrl(this.url(), "main");
     if (filepath.isErr()) {
-      throw this.logger.Error().Err(filepath.Err()).Str("url", this.url.toString()).Msg("error building url").AsError();
+      throw this.logger.Error().Err(filepath.Err()).Url(this.url()).Msg("error building url").AsError();
     }
     const bytes = await this.gateway.get(filepath.Ok());
     if (bytes.isErr()) {
@@ -2541,15 +2715,15 @@ var RemoteWAL = class extends VersionedStore {
       throw this.logger.Error().Err(bytes.Err()).Msg("error get").AsError();
     }
     try {
-      return bytes && (0, import_dag_json.parse)(textDecoder.decode(bytes.Ok()));
+      return bytes && (0, import_dag_json.parse)(this.sthis.txt.decode(bytes.Ok()));
     } catch (e) {
       throw this.logger.Error().Err(e).Msg("error parse").AsError();
     }
   }
   async save(state) {
-    const filepath = await this.gateway.buildUrl(this.url, "main");
+    const filepath = await this.gateway.buildUrl(this.url(), "main");
     if (filepath.isErr()) {
-      throw this.logger.Error().Err(filepath.Err()).Str("url", this.url.toString()).Msg("error building url").AsError();
+      throw this.logger.Error().Err(filepath.Err()).Url(this.url()).Msg("error building url").AsError();
     }
     let encoded;
     try {
@@ -2557,56 +2731,68 @@ var RemoteWAL = class extends VersionedStore {
     } catch (e) {
       throw this.logger.Error().Err(e).Any("state", state).Msg("error format").AsError();
     }
-    const res = await this.gateway.put(filepath.Ok(), textEncoder.encode(encoded));
+    const res = await this.gateway.put(filepath.Ok(), this.sthis.txt.encode(encoded));
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Str("filePath", filepath.Ok().toString()).Msg("error saving").AsError();
     }
   }
   async close() {
-    await this.gateway.close(this.url);
+    await this.gateway.close(this.url());
     this._onClosed.forEach((fn) => fn());
-    return import_cement5.Result.Ok(void 0);
+    return import_cement7.Result.Ok(void 0);
   }
   destroy() {
-    return this.gateway.destroy(this.url);
+    return this.gateway.destroy(this.url());
   }
 };
 
 // src/blockstore/store-factory.ts
 init_utils();
-function ensureIsIndex(url2, isIndex) {
+function ensureIsIndex(url, isIndex) {
   if (isIndex) {
-    url2.searchParams.set("index", isIndex);
-    return url2;
-  } else {
-    url2.searchParams.delete("index");
-    return url2;
+    return url.build().setParam("index", isIndex).URI();
   }
+  return url.build().delParam("index").URI();
 }
-function toURL(pathOrUrl, isIndex) {
-  if (pathOrUrl instanceof URL) return ensureIsIndex(pathOrUrl, isIndex);
-  try {
-    const url2 = new URL(pathOrUrl);
-    return ensureIsIndex(url2, isIndex);
-  } catch (e) {
-    const url2 = new URL(`file://${pathOrUrl}`);
-    return ensureIsIndex(url2, isIndex);
+function ensureName(name, url) {
+  if (!url.hasParam("name")) {
+    return url.build().setParam("name", name).URI();
   }
+  return url;
 }
 var storeFactory = /* @__PURE__ */ new Map();
-function ensureName(name, url2) {
-  if (!url2.searchParams.has("name")) {
-    url2.searchParams.set("name", name);
-  }
-}
 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 = new URL(obuItem.overrideBaseURL);
+    obuUrl = import_cement10.URI.from(obuItem.overrideBaseURL);
   }
-  return toURL(optURL || obuUrl || dataDir(loader.name, storeOpts.stores?.base), storeOpts.isIndex);
+  const ret = ensureIsIndex(
+    import_cement10.URI.from(optURL || obuUrl || dataDir(loader.sthis, loader.name, storeOpts.stores?.base)),
+    storeOpts.isIndex
+  );
+  return ret;
+}
+var onceGateway = new import_cement10.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;
+    }
+    sthis.logger.Warn().Url(url).Msg("unsupported protocol");
+    return void 0;
+  });
 }
 function registerStoreProtocol(item) {
   let protocol = item.protocol;
@@ -2615,8 +2801,7 @@ function registerStoreProtocol(item) {
   }
   if (storeFactory.has(protocol)) {
     if (!item.overrideBaseURL && storeFactory.get(protocol) !== item) {
-      const logger = ensureLogger({}, "registerStoreProtocol", { protocol });
-      logger.Warn().Msg(`protocol ${protocol} already registered`);
+      throw new Error(`we need a logger here`);
       return () => {
       };
     }
@@ -2631,106 +2816,83 @@ function registerStoreProtocol(item) {
     storeFactory.delete(protocol);
   };
 }
-function runStoreFactory(url2, logger, run) {
-  const item = storeFactory.get(url2.protocol);
-  if (!item) {
-    throw logger.Error().Url(url2).Str("protocol", url2.protocol).Any("keys", Array(storeFactory.keys())).Msg(`unsupported protocol`).AsError();
-  }
-  logger.Debug().Str("protocol", url2.protocol).Msg("run");
-  return run(item);
-}
-var onceLoadDataGateway = new import_cement8.KeyedResolvOnce();
-function loadDataGateway(url2, logger) {
-  return onceLoadDataGateway.get(url2.protocol).once(async () => {
-    return runStoreFactory(url2, logger, async (item) => item.data(logger));
-  });
-}
-var onceDataStoreFactory = new import_cement8.KeyedResolvOnce();
 async function dataStoreFactory(loader) {
-  const url2 = buildURL(loader.ebOpts.store.stores?.data, loader);
-  ensureName(loader.name, url2);
-  const logger = ensureLogger(loader.logger, "dataStoreFactory", { url: url2.toString() });
-  url2.searchParams.set("store", "data");
-  return onceDataStoreFactory.get(url2.toString()).once(async () => {
-    const gateway = await loadDataGateway(url2, logger);
-    const store = new DataStore(loader.name, url2, loader.logger, gateway);
-    const ret = await store.start();
-    if (ret.isErr()) {
-      throw logger.Error().Result("start", ret).Msg("start failed").AsError();
-    }
-    logger.Debug().Str("prepared", store.url.toString()).Msg("produced");
-    return store;
-  });
-}
-var onceLoadMetaGateway = new import_cement8.KeyedResolvOnce();
-function loadMetaGateway(url2, logger) {
-  return onceLoadMetaGateway.get(url2.protocol).once(async () => {
-    return runStoreFactory(url2, logger, async (item) => item.meta(logger));
+  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() });
+  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;
 }
-var onceMetaStoreFactory = new import_cement8.KeyedResolvOnce();
 async function metaStoreFactory(loader) {
-  const url2 = buildURL(loader.ebOpts.store.stores?.meta, loader);
-  ensureName(loader.name, url2);
-  const logger = ensureLogger(loader.logger, "metaStoreFactory", { url: () => url2.toString() });
-  url2.searchParams.set("store", "meta");
-  return onceMetaStoreFactory.get(url2.toString()).once(async () => {
-    logger.Debug().Str("protocol", url2.protocol).Msg("pre-protocol switch");
-    const gateway = await loadMetaGateway(url2, logger);
-    const store = new MetaStore(loader.name, url2, loader.logger, gateway);
-    const ret = await store.start();
-    if (ret.isErr()) {
-      throw logger.Error().Result("start", ret).Msg("start failed").AsError();
-    }
-    return store;
-  });
-}
-var onceWalGateway = new import_cement8.KeyedResolvOnce();
-function loadWalGateway(url2, logger) {
-  return onceWalGateway.get(url2.protocol).once(async () => {
-    return runStoreFactory(url2, logger, async (item) => item.wal(logger));
+  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() });
+  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 onceRemoteWalFactory = new import_cement8.KeyedResolvOnce();
 async function remoteWalFactory(loader) {
-  const url2 = buildURL(loader.ebOpts.store.stores?.meta, loader);
-  ensureName(loader.name, url2);
-  const logger = ensureLogger(loader.logger, "remoteWalFactory", { url: url2.toString() });
-  url2.searchParams.set("store", "wal");
-  return onceRemoteWalFactory.get(url2.toString()).once(async () => {
-    const gateway = await loadWalGateway(url2, logger);
-    logger.Debug().Str("prepared", url2.toString()).Msg("produced");
-    const store = new RemoteWAL(loader, url2, loader.logger, gateway);
-    const ret = await store.start();
-    if (ret.isErr()) {
-      throw logger.Error().Result("start", ret).Msg("start failed").AsError();
-    }
-    return store;
+  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() });
+  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 testStoreFactory(url2, ilogger) {
-  const logger = ensureLogger(
-    {
-      logger: ilogger
-    },
-    "testStoreFactory"
-  );
-  return runStoreFactory(url2, logger, async (item) => item.test(logger));
+async function testStoreFactory(url, sthis) {
+  sthis = ensureSuperLog(sthis, "testStoreFactory");
+  const gateway = await getGatewayFromURL(url, sthis);
+  if (!gateway) {
+    throw sthis.logger.Error().Url(url).Msg("gateway not found").AsError();
+  }
+  return gateway.test;
+}
+async function ensureStart(store, logger) {
+  const ret = await store.start();
+  if (ret.isErr()) {
+    throw logger.Error().Result("start", ret).Msg("start failed").AsError();
+  }
+  logger.Debug().Url(ret.Ok(), "prepared").Msg("produced");
+  return store;
 }
-function toStoreRuntime(opts, ilogger) {
-  const logger = ensureLogger(ilogger, "toStoreRuntime", {});
+function toStoreRuntime(opts, sthis) {
+  const logger = ensureLogger(sthis, "toStoreRuntime", {});
   return {
-    makeMetaStore: (loader) => {
+    makeMetaStore: async (loader) => {
       logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeMetaStore).Msg("makeMetaStore");
-      return (loader.ebOpts.store.makeMetaStore || metaStoreFactory)(loader);
+      return ensureStart(await (loader.ebOpts.store.makeMetaStore || metaStoreFactory)(loader), logger);
     },
-    makeDataStore: (loader) => {
+    makeDataStore: async (loader) => {
       logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeDataStore).Msg("makeDataStore");
-      return (loader.ebOpts.store.makeDataStore || dataStoreFactory)(loader);
+      return ensureStart(await (loader.ebOpts.store.makeDataStore || dataStoreFactory)(loader), logger);
     },
-    makeRemoteWAL: (loader) => {
-      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeRemoteWAL).Msg("makeRemoteWAL");
-      return (loader.ebOpts.store.makeRemoteWAL || remoteWalFactory)(loader);
+    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
@@ -2738,48 +2900,202 @@ function toStoreRuntime(opts, ilogger) {
 }
 registerStoreProtocol({
   protocol: "file:",
-  data: async (logger) => {
-    const { FileDataGateway: FileDataGateway2 } = await Promise.resolve().then(() => (init_store_file(), store_file_exports));
-    return new FileDataGateway2(logger);
-  },
-  meta: async (logger) => {
-    const { FileMetaGateway: FileMetaGateway2 } = await Promise.resolve().then(() => (init_store_file(), store_file_exports));
-    return new FileMetaGateway2(logger);
-  },
-  wal: async (logger) => {
-    const { FileWALGateway: FileWALGateway2 } = await Promise.resolve().then(() => (init_store_file(), store_file_exports));
-    return new FileWALGateway2(logger);
+  gateway: async (logger) => {
+    const { FileGateway: FileGateway2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
+    return new FileGateway2(logger);
   },
   test: async (logger) => {
-    const { FileTestStore: FileTestStore2 } = await Promise.resolve().then(() => (init_store_file(), store_file_exports));
+    const { FileTestStore: FileTestStore2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
     return new FileTestStore2(logger);
   }
 });
 registerStoreProtocol({
   protocol: "indexdb:",
-  data: async (logger) => {
-    const { IndexDBDataGateway: IndexDBDataGateway2 } = await Promise.resolve().then(() => (init_store_indexdb(), store_indexdb_exports));
-    return new IndexDBDataGateway2(logger);
-  },
-  meta: async (logger) => {
-    const { IndexDBMetaGateway: IndexDBMetaGateway2 } = await Promise.resolve().then(() => (init_store_indexdb(), store_indexdb_exports));
-    return new IndexDBMetaGateway2(logger);
-  },
-  wal: async (logger) => {
-    const { IndexDBMetaGateway: IndexDBMetaGateway2 } = await Promise.resolve().then(() => (init_store_indexdb(), store_indexdb_exports));
-    return new IndexDBMetaGateway2(logger);
+  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_store_indexdb(), store_indexdb_exports));
+    const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
     return new IndexDBTestStore2(logger);
   }
 });
 
-// src/blockstore/index.ts
-init_gateway();
+// src/blockstore/connection-base.ts
+var import_clock = require("@web3-storage/pail/clock");
+var import_block6 = require("@web3-storage/pail/block");
+
+// src/blockstore/task-manager.ts
+init_utils();
+var TaskManager = class {
+  constructor(loader) {
+    this.eventsWeHandled = /* @__PURE__ */ new Set();
+    this.queue = [];
+    this.isProcessing = false;
+    this.loader = loader;
+    this.logger = ensureLogger(loader.sthis, "TaskManager");
+  }
+  async handleEvent(eventBlock) {
+    const cid = eventBlock.cid.toString();
+    const parents = eventBlock.value.parents.map((cid2) => cid2.toString());
+    for (const parent of parents) {
+      this.eventsWeHandled.add(parent);
+    }
+    this.queue.push({ cid, eventBlock, 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 {
+      this.loader?.remoteMetaStore?.handleByteHeads([first.eventBlock.value.data.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();
+      }
+    }
+  }
+};
+
+// src/blockstore/store-remote.ts
+async function RemoteDataStore(sthis, name, url, opts) {
+  const ds = new DataStoreImpl(sthis, name, url, opts);
+  await ds.start();
+  return ds;
+}
+async function RemoteMetaStore(sthis, name, url, opts) {
+  const ms = new MetaStoreImpl(sthis, name, url, opts);
+  await ms.start();
+  return ms;
+}
+
+// src/blockstore/connection-base.ts
+var ConnectionBase = class {
+  constructor(url, logger) {
+    // readonly ready: Promise<unknown>;
+    // todo move to LRU blockstore https://github.com/web3-storage/w3clock/blob/main/src/worker/block.js
+    this.eventBlocks = new import_block6.MemoryBlockstore();
+    this.parents = [];
+    this.loaded = Promise.resolve();
+    this.logger = logger;
+    this.url = url;
+  }
+  async refresh() {
+    await throwFalsy(throwFalsy(this.loader).remoteMetaStore).load("main");
+    await (await throwFalsy(this.loader).WALStore()).process();
+  }
+  async connect_X({ loader }) {
+    if (!loader) throw this.logger.Error().Msg("loader is required").AsError();
+    await this.connectMeta_X({ loader });
+    await this.connectStorage_X({ loader });
+  }
+  async connectMeta_X({ loader }) {
+    if (!loader) throw this.logger.Error().Msg("connectMeta_X: loader is required").AsError();
+    this.loader = loader;
+    this.taskManager = new TaskManager(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 name = metaUrl.toString();
+    const remote = await RemoteMetaStore(loader.sthis, name, metaUrl, {
+      gateway: gateway.gateway,
+      keybag: () => getKeyBag(loader.sthis, loader.ebOpts.keyBag)
+    });
+    remote.onLoad("main", async (metas) => {
+      if (metas) {
+        this.logger.Debug().Any("metas", metas).Bool("loader", this.loader).Msg("connectMeta_X: handleDbMetasFromStore pre");
+        await throwFalsy(this.loader).handleDbMetasFromStore(metas);
+        this.logger.Debug().Any("metas", metas).Msg("connectMeta_X: handleDbMetasFromStore post");
+      }
+    });
+    this.loader.remoteMetaStore = remote;
+    this.loaded = this.loader.ready().then(async () => {
+      remote.load("main").then(async () => {
+        (await throwFalsy(this.loader).WALStore()).process();
+      });
+    });
+  }
+  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 name = dataUrl.toString();
+    loader.remoteCarStore = await RemoteDataStore(loader.sthis, name, this.url, {
+      gateway: gateway.gateway,
+      keybag: () => getKeyBag(loader.sthis, this.loader?.ebOpts.keyBag)
+    });
+    loader.remoteFileStore = loader.remoteCarStore;
+  }
+  async createEventBlock(bytes) {
+    const data = {
+      dbMeta: bytes
+    };
+    const event = await import_clock.EventBlock.create(
+      data,
+      this.parents
+    );
+    await this.eventBlocks.put(event.cid, event.bytes);
+    return event;
+  }
+  async decodeEventBlock(bytes) {
+    const event = await (0, import_clock.decodeEventBlock)(bytes);
+    return event;
+  }
+  // move this stuff to connect
+  // async getDashboardURL(compact = true) {
+  //   const baseUrl = 'https://dashboard.fireproof.storage/'
+  //   if (!this.loader?.remoteCarStore) return new URL('/howto', baseUrl)
+  //   // if (compact) {
+  //   //   await this.compact()
+  //   // }
+  //   const currents = await this.loader?.metaStore?.load()
+  //   if (!currents) throw new Error("Can't sync empty database: save data first")
+  //   if (currents.length > 1)
+  //     throw new Error("Can't sync database with split heads: make an update first")
+  //   const current = currents[0]
+  //   const params = {
+  //     car: current.car.toString()
+  //   }
+  //   if (current.key) {
+  //     // @ts-ignore
+  //     params.key = current.key.toString()
+  //   }
+  //   // @ts-ignore
+  //   if (this.name) {
+  //     // @ts-ignore
+  //     params.name = this.name
+  //   }
+  //   const url = new URL('/import#' + new URLSearchParams(params).toString(), baseUrl)
+  //   console.log('Import to dashboard: ' + url.toString())
+  //   return url
+  // }
+  // openDashboard() {
+  //   void this.getDashboardURL().then(url => {
+  //     if (url) window.open(url.toString(), '_blank')
+  //   })
+  // }
+};
 
 // src/crdt-helpers.ts
-init_types();
 function time(tag) {
 }
 function timeEnd(tag) {
@@ -2827,7 +3143,7 @@ async function writeDocContent(store, blocks, update, logger) {
     await processFiles(store, blocks, update.value, logger);
     value = { doc: update.value };
   }
-  const block = await (0, import_block6.encode)({ value, hasher: import_sha23.sha256, codec: codec2 });
+  const block = await encode({ value, hasher: import_sha25.sha256, codec });
   blocks.putSync(block.cid, block.bytes);
   return block.cid;
 }
@@ -2836,10 +3152,16 @@ async function processFiles(store, blocks, doc, logger) {
     await processFileset(logger, store, blocks, doc._files);
   }
   if (doc._publicFiles) {
-    await processFileset(logger, store, blocks, doc._publicFiles, true);
+    await processFileset(
+      logger,
+      store,
+      blocks,
+      doc._publicFiles
+      /*, true*/
+    );
   }
 }
-async function processFileset(logger, store, blocks, files, publicFiles = false) {
+async function processFileset(logger, store, blocks, files) {
   const dbBlockstore = blocks.parent;
   if (!dbBlockstore.loader) throw logger.Error().Msg("Missing loader, database name is required").AsError();
   const t = new CarTransaction(dbBlockstore);
@@ -2861,9 +3183,10 @@ async function processFileset(logger, store, blocks, files, publicFiles = false)
     }
   }
   if (didPut.length) {
-    const car = await dbBlockstore.loader.commitFiles(t, { files }, {
-      public: publicFiles
-    });
+    const car = await dbBlockstore.loader.commitFiles(
+      t,
+      { files }
+    );
     if (car) {
       for (const name of didPut) {
         files[name] = { car, ...files[name] };
@@ -2897,7 +3220,7 @@ function readFileset(blocks, files, isPublic = false) {
         fileMeta.file = async () => await blocks.ebOpts.storeRuntime.decodeFile(
           {
             get: async (cid) => {
-              return await blocks.getFile(throwFalsy(fileMeta.car), cid, isPublic);
+              return await blocks.getFile(throwFalsy(fileMeta.car), cid);
             }
           },
           fileMeta.cid,
@@ -2911,7 +3234,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 (0, import_block6.decode)({ bytes: block.bytes, hasher: import_sha23.sha256, codec: codec2 });
+  const { value } = await decode({ bytes: block.bytes, hasher: import_sha25.sha256, codec });
   const cvalue = {
     ...value,
     cid: link
@@ -2920,17 +3243,21 @@ async function getValueFromLink(blocks, link, logger) {
   return cvalue;
 }
 var DirtyEventFetcher = class extends import_clock2.EventFetcher {
+  constructor(logger, blocks) {
+    super(blocks);
+    this.logger = logger;
+  }
   async get(link) {
     try {
       return super.get(link);
     } catch (e) {
-      console.error("missing event", link.toString(), e);
+      this.logger.Error().Ref("link", link.toString()).Err(e).Msg("Missing event");
       return { value: void 0 };
     }
   }
 };
 async function clockChangesSince(blocks, head, since, opts, logger) {
-  const eventsFetcher = opts.dirty ? new DirtyEventFetcher(blocks) : new import_clock2.EventFetcher(blocks);
+  const eventsFetcher = opts.dirty ? new DirtyEventFetcher(logger, blocks) : new import_clock2.EventFetcher(blocks);
   const keys = /* @__PURE__ */ new Set();
   const updates = await gatherUpdates(
     blocks,
@@ -3028,38 +3355,34 @@ 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 (0, import_block6.decode)({ bytes: block.bytes, codec: codec2, hasher: import_sha23.sha256 });
-  return new import_block6.Block({ cid, value, bytes: block.bytes });
+  const { cid, value } = await decode({ 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_block7 = require("multiformats/block");
-var import_sha24 = require("multiformats/hashes/sha2");
-var codec3 = __toESM(require("@ipld/dag-cbor"), 1);
+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_utils12 = require("prolly-trees/utils");
-var import_cache2 = require("prolly-trees/cache");
+var import_utils15 = require("prolly-trees/utils");
+var import_cache = require("prolly-trees/cache");
 var IndexTree = class {
 };
 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_utils12.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_utils12.simpleCompare)(aKey, bKey);
+  const comp = (0, import_utils15.simpleCompare)(aKey, bKey);
   if (comp !== 0) return comp;
   return refCompare(aRef, bRef);
 }
-var byKeyOpts = { cache: import_cache2.nocache, chunker: (0, import_utils12.bf)(30), codec: codec3, hasher: import_sha24.sha256, compare };
-var byIdOpts = { cache: import_cache2.nocache, chunker: (0, import_utils12.bf)(30), codec: codec3, hasher: import_sha24.sha256, compare: import_utils12.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 }) => {
@@ -3087,7 +3410,7 @@ function makeProllyGetBlock(blocks) {
     const block = await blocks.get(address);
     if (!block) throw new Error(`Missing block ${address.toString()}`);
     const { cid, bytes } = block;
-    return (0, import_block7.create)({ cid, bytes, hasher: import_sha24.sha256, codec: codec3 });
+    return create({ cid, bytes, hasher: import_sha26.sha256, codec: codec2 });
   };
 }
 async function bulkIndex(tblocks, inIndex, indexEntries, opts) {
@@ -3159,25 +3482,25 @@ function encodeKey(key) {
 
 // src/indexer.ts
 init_utils();
-function index({ _crdt }, name, mapFn, meta) {
+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);
     idx.applyMapFn(name, mapFn, meta);
   } else {
-    const idx = new Index(_crdt, name, mapFn, meta);
+    const idx = new Index(sthis, _crdt, name, mapFn, meta);
     _crdt.indexers.set(name, idx);
   }
   return _crdt.indexers.get(name);
 }
 var Index = class {
-  constructor(crdt, name, mapFn, meta) {
+  constructor(sthis, crdt, name, mapFn, meta) {
     this.mapFnString = "";
     this.byKey = new IndexTree();
     this.byId = new IndexTree();
     this.includeDocsDefault = false;
-    this.logger = ensureLogger(crdt.logger, "Index");
+    this.logger = ensureLogger(sthis, "Index");
     this.blockstore = crdt.indexBlockstore;
     this.crdt = crdt;
     this.applyMapFn(name, mapFn, meta);
@@ -3232,7 +3555,7 @@ var Index = class {
           }
           if (this.mapFnString) {
             if (this.mapFnString !== mapFn.toString()) {
-              throw this.logger.Error().Msg("cannot apply different mapFn app").AsError();
+              throw this.logger.Error().Str("mapFnString", this.mapFnString).Str("mapFn", mapFn.toString()).Msg("cannot apply different mapFn app").AsError();
             }
           } else {
             this.mapFnString = mapFn.toString();
@@ -3367,8 +3690,7 @@ 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_cement9 = require("@adviser/cement");
-init_types();
+var import_cement11 = require("@adviser/cement");
 
 // src/apply-head-queue.ts
 function applyHeadQueue(worker, logger) {
@@ -3426,9 +3748,9 @@ var CRDTClock = class {
     this.zoomers = /* @__PURE__ */ new Set();
     this.watchers = /* @__PURE__ */ new Set();
     this.emptyWatchers = /* @__PURE__ */ new Set();
-    this._ready = new import_cement9.ResolveOnce();
+    this._ready = new import_cement11.ResolveOnce();
     this.blockstore = blockstore;
-    this.logger = ensureLogger(blockstore.logger, "CRDTClock");
+    this.logger = ensureLogger(blockstore.sthis, "CRDTClock");
     this.applyHeadQueue = applyHeadQueue(this.int_applyHead.bind(this), this.logger);
   }
   async ready() {
@@ -3501,7 +3823,7 @@ var CRDTClock = class {
         }
         return { head: advancedHead };
       },
-      { noLoader }
+      { noLoader, add: false }
     );
     this.setHead(meta.head);
   }
@@ -3536,13 +3858,14 @@ async function advanceBlocks(logger, newHead, tblocks, head) {
 // src/crdt.ts
 init_utils();
 var CRDT = class {
-  constructor(name, opts = {}) {
-    this.onceReady = new import_cement10.ResolveOnce();
+  constructor(sthis, name, opts = {}) {
     this.indexers = /* @__PURE__ */ new Map();
+    this.onceReady = new import_cement12.ResolveOnce();
+    this.sthis = sthis;
     this.name = name;
-    this.logger = ensureLogger(opts, "CRDT");
+    this.logger = ensureLogger(sthis, "CRDT");
     this.opts = opts;
-    this.blockstore = blockstoreFactory({
+    this.blockstore = blockstoreFactory(sthis, {
       name,
       applyMeta: async (meta) => {
         const crdtMeta = meta;
@@ -3554,22 +3877,20 @@ var CRDT = class {
         return { head: this.clock.head };
       },
       autoCompact: this.opts.autoCompact || 100,
-      crypto: this.opts.crypto,
       store: { ...this.opts.store, isIndex: void 0 },
       public: this.opts.public,
       meta: this.opts.meta,
       threshold: this.opts.threshold
     });
-    this.indexBlockstore = blockstoreFactory({
+    this.indexBlockstore = blockstoreFactory(sthis, {
       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({ _crdt: this }, name2, void 0, idx);
+          index(this.sthis, { _crdt: this }, name2, void 0, idx);
         }
       },
-      crypto: this.opts.crypto,
       store: { ...this.opts.store, isIndex: this.opts.store?.isIndex || "idx" },
       public: this.opts.public
     });
@@ -3580,17 +3901,6 @@ var CRDT = class {
       }
     });
   }
-  async ready() {
-    return this.onceReady.once(async () => {
-      await Promise.all([this.blockstore.ready(), this.indexBlockstore.ready(), this.clock.ready()]);
-    });
-  }
-  async close() {
-    await Promise.all([this.blockstore.close(), this.indexBlockstore.close(), this.clock.close()]);
-  }
-  async destroy() {
-    await Promise.all([this.blockstore.destroy(), this.indexBlockstore.destroy()]);
-  }
   async bulk(updates) {
     await this.ready();
     const prevHead = [...this.clock.head];
@@ -3611,6 +3921,21 @@ var CRDT = class {
     await this.clock.applyHead(done.meta.head, prevHead, updates);
     return done.meta;
   }
+  async ready() {
+    return this.onceReady.once(async () => {
+      try {
+        await Promise.all([this.blockstore.ready(), this.indexBlockstore.ready(), this.clock.ready()]);
+      } catch (e) {
+        throw this.logger.Error().Err(e).Msg("CRDT not ready").AsError();
+      }
+    });
+  }
+  async close() {
+    await Promise.all([this.blockstore.close(), this.indexBlockstore.close(), this.clock.close()]);
+  }
+  async destroy() {
+    await Promise.all([this.blockstore.destroy(), this.indexBlockstore.destroy()]);
+  }
   // if (snap) await this.clock.applyHead(crdtMeta.head, this.clock.head)
   async allDocs() {
     await this.ready();
@@ -3649,20 +3974,19 @@ var CRDT = class {
 };
 
 // src/database.ts
-init_sys_container();
 init_utils();
-init_gateway();
 var Database = class {
   constructor(name, opts) {
     this.opts = {};
     this._listening = false;
     this._listeners = /* @__PURE__ */ new Set();
     this._noupdate_listeners = /* @__PURE__ */ new Set();
-    this._ready = new import_cement11.ResolveOnce();
+    this._ready = new import_cement13.ResolveOnce();
     this.name = name;
     this.opts = opts || this.opts;
-    this.logger = ensureLogger(this.opts, "Database");
-    this._crdt = new CRDT(name, this.opts);
+    this.sthis = ensureSuperThis(this.opts);
+    this.logger = ensureLogger(this.sthis, "Database");
+    this._crdt = new CRDT(this.sthis, name, this.opts);
     this.blockstore = this._crdt.blockstore;
     this._writeQueue = writeQueue(async (updates) => {
       return await this._crdt.bulk(updates);
@@ -3686,7 +4010,7 @@ var Database = class {
   }
   async ready() {
     return this._ready.once(async () => {
-      await SysContainer.start();
+      await this.sthis.start();
       await this._crdt.ready();
       await this.blockstore.ready();
     });
@@ -3706,7 +4030,7 @@ var Database = class {
     await this.ready();
     this.logger.Debug().Str("id", doc._id).Msg("put");
     const { _id, ...value } = doc;
-    const docId = _id || (0, import_uuidv73.uuidv7)();
+    const docId = _id || this.sthis.nextId().str;
     const result = await this._writeQueue.push({
       id: docId,
       value: {
@@ -3771,7 +4095,7 @@ var Database = class {
     await this.ready();
     this.logger.Debug().Any("field", field).Any("opts", opts).Msg("query");
     const _crdt = this._crdt;
-    const idx = typeof field === "string" ? index({ _crdt }, field) : index({ _crdt }, makeName(field.toString()), field);
+    const idx = typeof field === "string" ? index(this.sthis, { _crdt }, field) : index(this.sthis, { _crdt }, makeName(field.toString()), field);
     return await idx.query(opts);
   }
   async compact() {
@@ -3808,12 +4132,7 @@ function fireproof(name, opts) {
   const key = JSON.stringify(
     toSortedArray({
       name,
-      stores: toSortedArray(opts?.store?.stores),
-      makeMetaStore: !!opts?.store?.makeMetaStore,
-      makeDataStore: !!opts?.store?.makeDataStore,
-      makeRemoteWAL: !!opts?.store?.makeRemoteWAL,
-      encodeFile: !!opts?.store?.encodeFile,
-      decodeFile: !!opts?.store?.decodeFile
+      stores: toSortedArray(opts?.store?.stores)
     })
   );
   let db = Database.databases.get(key);
@@ -3828,7 +4147,10 @@ function makeName(fnString) {
   let found = null;
   const matches = Array.from(fnString.matchAll(regex), (match) => match[1].trim());
   if (matches.length === 0) {
-    found = /=>\s*(.*)/.exec(fnString);
+    found = /=>\s*{?\s*([^{}]+)\s*}?/.exec(fnString);
+    if (found && found[1].includes("return")) {
+      found = null;
+    }
   }
   if (!found) {
     return fnString;
@@ -3837,14 +4159,41 @@ function makeName(fnString) {
   }
 }
 
+// src/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  FILESTORE_VERSION: () => FILESTORE_VERSION,
+  INDEXDB_VERSION: () => INDEXDB_VERSION,
+  files: () => files_exports,
+  getFileName: () => getFileName,
+  getFileSystem: () => getFileSystem,
+  getPath: () => getPath,
+  kb: () => key_bag_exports,
+  kc: () => keyed_crypto_exports,
+  mf: () => wait_pr_multiformats_exports,
+  toArrayBuffer: () => toArrayBuffer
+});
+init_utils2();
+
+// src/runtime/wait-pr-multiformats/index.ts
+var wait_pr_multiformats_exports = {};
+__export(wait_pr_multiformats_exports, {
+  block: () => block_exports,
+  codec: () => codec_interface_exports
+});
+
+// src/runtime/wait-pr-multiformats/codec-interface.ts
+var codec_interface_exports = {};
+
+// src/runtime/index.ts
+init_version();
+init_version2();
+
 // src/index.ts
-init_types();
-init_runtime();
-init_runtime();
 init_utils();
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.8-dev-global": "xxxx"
+  "0.19.9-dev-frag": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map