@fireproof/core 0.18.0 → 0.19.0-dev-publish

package/index.cjs

@@ -0,0 +1,4676 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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() {
+  const nodePath = "node:path";
+  const nodeOS = "node:os";
+  const nodeURL = "node:url";
+  const nodeFS = "node:fs";
+  const fs = (await import(nodeFS)).promises;
+  const path = await import(nodePath);
+  return {
+    state: "node",
+    ...path,
+    ...await import(nodeOS),
+    ...await import(nodeURL),
+    ...fs,
+    join,
+    stat: fs.stat,
+    readdir: fs.readdir,
+    readfile: fs.readFile,
+    writefile: fs.writeFile
+  };
+}
+var init_node_sys_container = __esm({
+  "src/runtime/node-sys-container.ts"() {
+    "use strict";
+    init_sys_container();
+  }
+});
+
+// src/runtime/sys-container.ts
+function join(...paths) {
+  return paths.map((i) => i.replace(/\/+$/, "")).join("/");
+}
+var stdEnv, import_uuidv7, import_cement, onceStart, envImpl, sysContainer, SysContainer;
+var init_sys_container = __esm({
+  "src/runtime/sys-container.ts"() {
+    "use strict";
+    stdEnv = __toESM(require("std-env"), 1);
+    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: (path) => path.split("/").slice(0, -1).join("/"),
+          homedir: () => {
+            throw new Error("SysContainer:homedir is not available in seeded state");
+          },
+          fileURLToPath: (strurl) => {
+            let url;
+            if (typeof strurl === "string") {
+              url = new URL(strurl);
+            } else {
+              url = strurl;
+            }
+            return url.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.env = envImpl;
+      }
+      async start() {
+        await onceStart.once(async () => {
+          switch (this.freight.state) {
+            case "seeded":
+              if (stdEnv.isNode) {
+                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(path, options) {
+        this.logSeeded("readdir");
+        return throwFalsy(this.freight).readdir(path, options) || [];
+      }
+      async readdirent(path, options) {
+        this.logSeeded("readdirent");
+        return throwFalsy(this.freight).readdir(path, { ...options, withFileTypes: true }) || [];
+      }
+      async readfile(path, options) {
+        this.logSeeded("readfile");
+        return throwFalsy(this.freight).readfile(path, options);
+      }
+      async mkdir(path, options) {
+        this.logSeeded("mkdir");
+        return throwFalsy(this.freight).mkdir(path, options);
+      }
+      async rm(path, options) {
+        this.logSeeded("rm");
+        return throwFalsy(this.freight).rm(path, options);
+      }
+      async unlink(path) {
+        this.logSeeded("unlink");
+        return throwFalsy(this.freight).unlink(path);
+      }
+      async writefile(path, data) {
+        this.logSeeded("writefile");
+        return throwFalsy(this.freight).writefile(path, data);
+      }
+      async copyFile(source, destination) {
+        this.logSeeded("copyFile");
+        return throwFalsy(this.freight).copyFile(source, destination);
+      }
+      async stat(path) {
+        this.logSeeded("stat");
+        return throwFalsy(this.freight).stat(path);
+      }
+      fileURLToPath(url) {
+        this.logSeeded("fileURLToPath");
+        return throwFalsy(this.freight).fileURLToPath(url);
+      }
+      dirname(path) {
+        this.logSeeded("dirname");
+        return throwFalsy(this.freight).dirname(path);
+      }
+      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 (import_std_env.isNode || import_std_env.isDeno) {
+      base = SysContainer.env.get("FP_STORAGE_URL") || `file://${SysContainer.join(SysContainer.homedir(), ".fireproof")}`;
+    } else {
+      base = `indexdb://fp`;
+    }
+  }
+  let url;
+  if (typeof base === "string") {
+    try {
+      url = new URL(base.toString());
+    } catch (e) {
+      try {
+        base = `file://${base}`;
+        url = new URL(base);
+      } catch (e2) {
+        throw new Error(`invalid base url: ${base}`);
+      }
+    }
+  } else {
+    url = base;
+  }
+  url.searchParams.set("name", name || "");
+  return url.toString();
+}
+var import_std_env;
+var init_data_dir = __esm({
+  "src/runtime/data-dir.ts"() {
+    "use strict";
+    init_sys_container();
+    import_std_env = require("std-env");
+  }
+});
+
+// src/runtime/store-file-utils.ts
+async function getPath(url, logger) {
+  const basePath = url.toString().replace(new RegExp(`^${url.protocol}//`), "").replace(/\?.*$/, "");
+  const name = url.searchParams.get("name");
+  if (name) {
+    const version = url.searchParams.get("version");
+    if (!version) throw logger.Error().Str("url", url.toString()).Msg(`version not found`).AsError();
+    return SysContainer.join(basePath, version, name);
+  }
+  return SysContainer.join(basePath);
+}
+function getFileName(url, key, logger) {
+  switch (getStore(url, logger, (...a) => a.join("/"))) {
+    case "data":
+      return key + ".car";
+    case "meta":
+      return key + ".json";
+    default:
+      throw logger.Error().Str("url", url.toString()).Msg(`unsupported store type`).AsError();
+  }
+}
+function ensureIndexName(url, name) {
+  if (url.searchParams.has("index")) {
+    name = (url.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/store-sql/types.ts
+var DefaultSQLTableNames;
+var init_types2 = __esm({
+  "src/runtime/store-sql/types.ts"() {
+    "use strict";
+    DefaultSQLTableNames = {
+      data: "Datas",
+      meta: "Metas",
+      wal: "Wals"
+    };
+  }
+});
+
+// src/runtime/store-sql/ensurer.ts
+function sqlTableName(...names) {
+  return names.map((name) => name.replace(/^[^a-zA-Z0-9]+/, "").replace(/[^a-zA-Z0-9]+/g, "_")).filter((i) => i.length).join("_");
+}
+function ensureTableNames(url, opts) {
+  let isIndex = "";
+  if (url.searchParams.has("index")) {
+    isIndex = url.searchParams.get("index") || ".idx";
+  }
+  const ret = opts?.tableNames || DefaultSQLTableNames;
+  if (isIndex.length) {
+    return {
+      data: sqlTableName(isIndex, ret.data),
+      meta: sqlTableName(isIndex, ret.meta),
+      wal: sqlTableName(isIndex, ret.wal)
+    };
+  }
+  return {
+    data: sqlTableName(ret.data),
+    meta: sqlTableName(ret.meta),
+    wal: sqlTableName(ret.wal)
+  };
+}
+function ensureTextEncoder(opts) {
+  return opts?.textEncoder || textEncoder;
+}
+function ensureTextDecoder(opts) {
+  return opts?.textDecoder || textDecoder;
+}
+function url2sqlFlavor(url, logger) {
+  const flavor = url.protocol.replace(/:.*$/, "");
+  switch (flavor) {
+    case "sqlite":
+    case "mysql":
+    case "postgres":
+      return flavor;
+    default:
+      throw logger.Error().Str("flavor", flavor).Msg("unsupported protocol").AsError();
+  }
+}
+function ensureSQLOpts(url, opts, componentName, ctx) {
+  const logger = ensureLogger(opts, componentName, ctx);
+  return {
+    url,
+    sqlFlavor: url2sqlFlavor(url, logger),
+    tableNames: ensureTableNames(url, opts),
+    logger,
+    textEncoder: ensureTextEncoder(opts),
+    textDecoder: ensureTextDecoder(opts)
+  };
+}
+var textEncoder, textDecoder;
+var init_ensurer = __esm({
+  "src/runtime/store-sql/ensurer.ts"() {
+    "use strict";
+    init_utils();
+    init_types2();
+    textEncoder = new TextEncoder();
+    textDecoder = new TextDecoder();
+  }
+});
+
+// src/runtime/store-sql/index.ts
+var store_sql_exports = {};
+__export(store_sql_exports, {
+  DefaultSQLTableNames: () => DefaultSQLTableNames,
+  ensureSQLOpts: () => ensureSQLOpts
+});
+var init_store_sql = __esm({
+  "src/runtime/store-sql/index.ts"() {
+    "use strict";
+    init_types2();
+    init_ensurer();
+  }
+});
+
+// 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/store-sql/v0.19-sqlite/version.ts
+var SQLITE_VERSION;
+var init_version = __esm({
+  "src/runtime/store-sql/v0.19-sqlite/version.ts"() {
+    "use strict";
+    SQLITE_VERSION = "v0.19-sqlite";
+  }
+});
+
+// src/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  FILESTORE_VERSION: () => FILESTORE_VERSION,
+  INDEXDB_VERSION: () => INDEXDB_VERSION,
+  SQLITE_VERSION: () => SQLITE_VERSION,
+  SysContainer: () => SysContainer,
+  dataDir: () => dataDir,
+  ensureIndexName: () => ensureIndexName,
+  getFileName: () => getFileName,
+  getPath: () => getPath,
+  join: () => join,
+  sql: () => store_sql_exports
+});
+var init_runtime = __esm({
+  "src/runtime/index.ts"() {
+    "use strict";
+    init_sys_container();
+    init_data_dir();
+    init_store_file_utils();
+    init_store_sql();
+    init_store_file_version();
+    init_store_indexdb_version();
+    init_version();
+  }
+});
+
+// src/utils.ts
+function ensureLogger(optsOrLogger, 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;
+  }
+  const cLogger = logger.With().Module(componentName);
+  const debug = [];
+  if (ctx) {
+    if ("debug" in ctx) {
+      if (typeof ctx.debug === "string" && ctx.debug.length > 0) {
+        debug.push(ctx.debug);
+      } else {
+        debug.push(componentName);
+      }
+      delete ctx.debug;
+    }
+    if ("this" in ctx) {
+      cLogger.Str("this", (0, import_uuidv72.uuidv7)());
+      delete ctx.this;
+    }
+    for (const [key, value] of Object.entries(ctx)) {
+      switch (typeof value) {
+        case "string":
+          cLogger.Str(key, value);
+          break;
+        case "number":
+          cLogger.Uint64(key, value);
+          break;
+        default:
+          if (value instanceof Date) {
+            cLogger.Str(key, value.toISOString());
+          } else if (value instanceof URL) {
+            cLogger.Str(key, value.toString());
+          } else if (typeof value === "function") {
+            cLogger.Ref(key, value);
+          } else {
+            cLogger.Any(key, value);
+          }
+          break;
+      }
+    }
+  }
+  registerFP_DEBUG.once(async () => {
+    SysContainer.env.onSet((key, value) => {
+      if (value) {
+        logger.SetDebug(value);
+      }
+    }, "FP_DEBUG");
+  }).finally(() => {
+  });
+  if (debug.length > 0) {
+    logger.SetDebug(debug);
+  }
+  const out = cLogger.Logger();
+  return out;
+}
+function getStore(url, logger, joiner) {
+  let result = url.searchParams.get("store");
+  if (!result) throw logger.Error().Str("url", url.toString()).Msg(`store not found`).AsError();
+  if (url.searchParams.has("index")) {
+    result = joiner(url.searchParams.get("index") || "idx", result);
+  }
+  return result;
+}
+function getKey(url, logger) {
+  const result = url.searchParams.get("key");
+  if (!result) throw logger.Error().Str("url", url.toString()).Msg(`key not found`).AsError();
+  return result;
+}
+function getName(url, logger) {
+  let result = url.searchParams.get("name");
+  if (!result) {
+    result = SysContainer.dirname(url.pathname);
+    if (result.length === 0) {
+      throw 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));
+}
+async function exceptionWrapper(fn) {
+  return fn().catch((e) => import_cement2.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 (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"() {
+    "use strict";
+    import_cement3 = require("@adviser/cement");
+    NotFoundError = class extends Error {
+      constructor() {
+        super(...arguments);
+        this.code = "ENOENT";
+      }
+    };
+  }
+});
+
+// src/runtime/store-indexdb.ts
+var store_indexdb_exports = {};
+__export(store_indexdb_exports, {
+  IndexDBDataGateway: () => IndexDBDataGateway,
+  IndexDBMetaGateway: () => IndexDBMetaGateway,
+  IndexDBTestStore: () => IndexDBTestStore,
+  IndexDBWalGateway: () => IndexDBWalGateway,
+  getIndexDBName: () => getIndexDBName,
+  guardVersion: () => guardVersion
+});
+function ensureVersion(url) {
+  const ret = new URL(url.toString());
+  ret.searchParams.set("version", url.searchParams.get("version") || INDEXDB_VERSION);
+  return ret;
+}
+function guardVersion(url) {
+  if (!url.searchParams.has("version")) {
+    return import_cement4.Result.Err(`missing version: ${url.toString()}`);
+  }
+  return import_cement4.Result.Ok(url);
+}
+function sanitzeKey(key) {
+  if (key.length === 1) {
+    key = key[0];
+  }
+  return key;
+}
+async function connectIdb(url, logger) {
+  const dbName = getIndexDBName(url, logger);
+  const once2 = await onceIndexDB.get(dbName.fullDb).once(async () => {
+    const db = await (0, import_idb.openDB)(dbName.fullDb, 1, {
+      upgrade(db2) {
+        ["version", "data", "wal", "meta", "idx.data", "idx.wal", "idx.meta"].map((store) => {
+          db2.createObjectStore(store, {
+            autoIncrement: false
+          });
+        });
+      }
+    });
+    const found = await db.get("version", "version");
+    const version = url.searchParams.get("version") || INDEXDB_VERSION;
+    if (!found) {
+      await db.put("version", { version }, "version");
+    } else if (found.version !== version) {
+      logger.Warn().Str("url", url.toString()).Str("version", version).Str("found", found.version).Msg("version mismatch");
+    }
+    return { db, dbName, version };
+  });
+  url.searchParams.set("version", once2.version);
+  return once2.db;
+}
+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 url = ensureVersion(iurl);
+  const fullDb = url.pathname.replace(/^\/+/, "").replace(/\?.*$/, "");
+  const dbName = url.searchParams.get("name");
+  if (!dbName) throw logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
+  const result = joinDBName(fullDb, dbName);
+  const objStore = getStore(url, logger, joinDBName);
+  const connectionKey = [result, objStore].join(":");
+  return {
+    fullDb: result,
+    objStore,
+    connectionKey,
+    dbName
+  };
+}
+var import_idb, import_cement4, onceIndexDB, IndexDBGateway, IndexDBDataGateway, IndexDBWalGateway, IndexDBMetaGateway, txtEncoder, IndexDBTestStore;
+var init_store_indexdb = __esm({
+  "src/runtime/store-indexdb.ts"() {
+    "use strict";
+    import_idb = require("idb");
+    import_cement4 = require("@adviser/cement");
+    init_store_indexdb_version();
+    init_utils();
+    init_gateway();
+    init_sys_container();
+    onceIndexDB = new import_cement4.KeyedResolvOnce();
+    IndexDBGateway = class {
+      constructor(logger) {
+        this.db = {};
+        this.logger = logger;
+      }
+      idb() {
+        this.db;
+      }
+      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");
+        });
+      }
+      async close() {
+        return import_cement4.Result.Ok(void 0);
+      }
+      async destroy(baseUrl) {
+        return exception2Result(async () => {
+          const type = getStore(baseUrl, this.logger, joinDBName);
+          const idb = this.db;
+          const trans = idb.transaction(type, "readwrite");
+          const object_store = trans.objectStore(type);
+          const toDelete = [];
+          for (let cursor = await object_store.openCursor(); cursor; cursor = await cursor.continue()) {
+            toDelete.push(cursor.primaryKey);
+          }
+          for (const key of toDelete) {
+            await trans.db.delete(type, key);
+          }
+          await trans.done;
+        });
+      }
+      async get(url) {
+        return exceptionWrapper(async () => {
+          const key = getKey(url, this.logger);
+          const store = getStore(url, this.logger, joinDBName);
+          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_cement4.Result.Err(new NotFoundError(`missing ${key}`));
+          }
+          return import_cement4.Result.Ok(bytes);
+        });
+      }
+      async put(url, value) {
+        return exception2Result(async () => {
+          const key = getKey(url, this.logger);
+          const store = getStore(url, this.logger, joinDBName);
+          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(url) {
+        return exception2Result(async () => {
+          const key = getKey(url, this.logger);
+          const store = getStore(url, this.logger, joinDBName);
+          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_cement4.Result.Ok(void 0);
+        });
+      }
+    };
+    IndexDBDataGateway = class extends IndexDBGateway {
+      constructor(logger) {
+        super(ensureLogger(logger, "IndexDBDataGateway", {}));
+      }
+      buildUrl(baseUrl, key) {
+        const url = new URL(baseUrl.toString());
+        url.searchParams.set("key", key);
+        return Promise.resolve(import_cement4.Result.Ok(url));
+      }
+    };
+    IndexDBWalGateway = class extends IndexDBGateway {
+      constructor(logger) {
+        super(ensureLogger(logger, "IndexDBWalGateway", {}));
+      }
+      buildUrl(baseUrl, key) {
+        const url = new URL(baseUrl.toString());
+        url.searchParams.set("key", key);
+        return Promise.resolve(import_cement4.Result.Ok(url));
+      }
+    };
+    IndexDBMetaGateway = class extends IndexDBGateway {
+      constructor(logger) {
+        super(ensureLogger(logger, "IndexDBDataGateway", {}));
+        this.branches = /* @__PURE__ */ new Set();
+      }
+      async buildUrl(baseUrl, key) {
+        const url = new URL(baseUrl.toString());
+        this.branches.add(key);
+        url.searchParams.set("key", key);
+        return import_cement4.Result.Ok(url);
+      }
+    };
+    txtEncoder = new TextEncoder();
+    IndexDBTestStore = class {
+      constructor(logger) {
+        this.logger = ensureLogger(logger, "IndexDBTestStore", {});
+      }
+      async get(url, key) {
+        const db = await connectIdb(url, this.logger);
+        const store = getStore(url, this.logger, joinDBName);
+        this.logger.Debug().Str("key", key).Str("store", store).Msg("getting");
+        let bytes = await 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);
+        }
+        return bytes;
+      }
+    };
+  }
+});
+
+// src/runtime/store-file.ts
+var store_file_exports = {};
+__export(store_file_exports, {
+  FileDataGateway: () => FileDataGateway,
+  FileMetaGateway: () => FileMetaGateway,
+  FileTestStore: () => FileTestStore,
+  FileWALGateway: () => FileWALGateway
+});
+async function ensureVersionFile(path, logger) {
+  let once2 = versionFiles.get(path);
+  if (!once2) {
+    once2 = new import_cement7.ResolveOnce();
+    versionFiles.set(path, once2);
+  }
+  await once2.once(async () => {
+    await SysContainer.mkdir(path, { recursive: true });
+    const vFile = SysContainer.join(path, "version");
+    const vFileStat = await SysContainer.stat(vFile).catch(() => void 0);
+    if (!vFileStat) {
+      await SysContainer.writefile(SysContainer.join(path, "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}`);
+    }
+  });
+  return path;
+}
+function toArrayBuffer(buffer) {
+  const ab = new ArrayBuffer(buffer.length);
+  const view = new Uint8Array(ab);
+  for (let i = 0; i < buffer.length; ++i) {
+    view[i] = buffer[i];
+  }
+  return view;
+}
+var import_cement7, versionFiles, FileGateway, FileWALGateway, FileMetaGateway, FileDataGateway, FileTestStore;
+var init_store_file = __esm({
+  "src/runtime/store-file.ts"() {
+    "use strict";
+    init_sys_container();
+    init_store_file_version();
+    import_cement7 = require("@adviser/cement");
+    init_utils();
+    init_gateway();
+    init_store_file_utils();
+    versionFiles = /* @__PURE__ */ new Map();
+    FileGateway = class {
+      constructor(logger) {
+        this.logger = logger;
+      }
+      start(baseURL) {
+        return exception2Result(async () => {
+          await SysContainer.start();
+          baseURL.searchParams.set("version", baseURL.searchParams.get("version") || FILESTORE_VERSION);
+          const url = await this.buildUrl(baseURL, "dummy");
+          if (url.isErr()) return url;
+          const dbdir = this.getFilePath(url.Ok());
+          await SysContainer.mkdir(SysContainer.dirname(dbdir), { recursive: true });
+          const dbroot = SysContainer.dirname(dbdir);
+          this.logger.Debug().Str("url", url.Ok().toString()).Str("dbroot", SysContainer.dirname(dbroot)).Msg("start");
+          await ensureVersionFile(dbroot, this.logger);
+        });
+      }
+      async close() {
+        return import_cement7.Result.Ok(void 0);
+      }
+      getFilePath(url) {
+        const path = url.toString().replace(/^file:\/\//, "").replace(/\?.*$/, "");
+        this.logger.Debug().Str("url", url.toString()).Str("path", path).Msg("getFilePath");
+        return path;
+      }
+      async put(url, body) {
+        return exception2Result(async () => {
+          const file = this.getFilePath(url);
+          this.logger.Debug().Str("url", url.toString()).Str("file", file).Msg("put");
+          await SysContainer.writefile(file, body);
+        });
+      }
+      async get(url) {
+        return exceptionWrapper(async () => {
+          const file = this.getFilePath(url);
+          try {
+            const res = await SysContainer.readfile(file);
+            this.logger.Debug().Url(url).Str("file", file).Msg("get");
+            return import_cement7.Result.Ok(new Uint8Array(res));
+          } catch (e) {
+            if (isNotFoundError(e)) {
+              return import_cement7.Result.Err(new NotFoundError(`file not found: ${file}`));
+            }
+            return import_cement7.Result.Err(e);
+          }
+        });
+      }
+      async delete(url) {
+        return exception2Result(async () => {
+          await SysContainer.unlink(this.getFilePath(url));
+        });
+      }
+      async destroyDir(baseURL) {
+        const url = await this.buildUrl(baseURL, "x");
+        if (url.isErr()) return url;
+        const filepath = SysContainer.dirname(this.getFilePath(url.Ok()));
+        let dir = [];
+        try {
+          dir = await SysContainer.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);
+          try {
+            await SysContainer.unlink(pathed);
+          } catch (e) {
+            if (!isNotFoundError(e)) {
+              throw this.logger.Error().Err(e).Str("file", pathed).Msg("destroy:unlink").AsError();
+            }
+          }
+        }
+        return import_cement7.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 url = new URL(baseUrl.toString());
+        url.pathname = SysContainer.join(await getPath(baseUrl, this.logger), ensureIndexName(baseUrl, "wal"), key + ".json");
+        return import_cement7.Result.Ok(url);
+      }
+    };
+    FileMetaGateway = class extends FileGateway {
+      constructor(logger) {
+        super(ensureLogger(logger, "FileMetaGateway"));
+      }
+      async destroy(baseURL) {
+        return this.destroyDir(baseURL);
+      }
+      async buildUrl(baseUrl, key) {
+        const url = new URL(baseUrl.toString());
+        url.pathname = SysContainer.join(await getPath(baseUrl, this.logger), ensureIndexName(baseUrl, "meta"), key + ".json");
+        return import_cement7.Result.Ok(url);
+      }
+    };
+    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 url = new URL(baseUrl.toString());
+        url.pathname = SysContainer.join(await getPath(baseUrl, this.logger), ensureIndexName(baseUrl, "data"), key + ".car");
+        return import_cement7.Result.Ok(url);
+      }
+    };
+    FileTestStore = class {
+      constructor(logger) {
+        this.logger = ensureLogger(logger, "FileTestStore");
+      }
+      async get(url, key) {
+        const logger = ensureLogger(this.logger, "get", { url: url.toString(), key });
+        const dbFile = SysContainer.join(
+          await getPath(url, this.logger),
+          getStore(url, this.logger, SysContainer.join),
+          getFileName(url, 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);
+      }
+    };
+  }
+});
+
+// src/runtime/store-sql/sqlite-adapter-better-sqlite3.ts
+var import_cement8, onceSQLiteConnections, SQLiteConnection;
+var init_sqlite_adapter_better_sqlite3 = __esm({
+  "src/runtime/store-sql/sqlite-adapter-better-sqlite3.ts"() {
+    "use strict";
+    import_cement8 = require("@adviser/cement");
+    init_sys_container();
+    init_ensurer();
+    onceSQLiteConnections = new import_cement8.KeyedResolvOnce();
+    SQLiteConnection = class _SQLiteConnection {
+      static fromURL(url, opts = {}) {
+        return new _SQLiteConnection(url, opts);
+      }
+      get client() {
+        if (!this._client) {
+          throw this.logger.Error().Msg("client not connected").AsError();
+        }
+        return this._client;
+      }
+      constructor(url, opts) {
+        this.opts = ensureSQLOpts(url, opts, "SQLiteConnection", { url });
+        this.logger = this.opts.logger;
+        this.url = url;
+        this.logger.Debug().Msg("constructor");
+      }
+      async connect() {
+        let fName = this.url.toString().replace("sqlite://", "").replace(/\?.*$/, "");
+        if (!fName) {
+          throw this.logger.Error().Str("url", this.url.toString()).Msg("filename is empty").AsError();
+        }
+        const hasName = this.url.searchParams.get("name");
+        if (hasName) {
+          fName = SysContainer.join(fName, hasName);
+          if (!fName.endsWith(".sqlite")) {
+            fName += ".sqlite";
+          }
+        }
+        this._client = await onceSQLiteConnections.get(fName).once(async () => {
+          this.logger.Debug().Str("filename", fName).Msg("connect");
+          const Sqlite3Database = (await import("better-sqlite3")).default;
+          if (hasName) {
+            await SysContainer.mkdir(SysContainer.dirname(fName), { recursive: true });
+          }
+          const db = new Sqlite3Database(fName, {
+            // verbose: console.log,
+            nativeBinding: "./node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+          });
+          if (!db) {
+            throw this.logger.Error().Msg("connect failed").AsError();
+          }
+          return db;
+        });
+      }
+      async close() {
+        this.logger.Debug().Msg("close");
+        await this.client.close();
+      }
+    };
+  }
+});
+
+// src/runtime/store-sql/sql-connection-factory.ts
+function SQLConnectionFactory(databaseURL, opts = {}) {
+  const logger = ensureLogger(opts, "SQLFactory");
+  switch (databaseURL.protocol) {
+    case "sqlite:":
+      logger.Debug().Str("databaseURL", databaseURL.toString()).Msg("connecting to sqlite");
+      return SQLiteConnection.fromURL(databaseURL, {
+        ...opts,
+        logger
+      });
+    default:
+      throw logger.Error().Msg("unsupported protocol " + databaseURL.protocol).AsError();
+  }
+}
+var init_sql_connection_factory = __esm({
+  "src/runtime/store-sql/sql-connection-factory.ts"() {
+    "use strict";
+    init_utils();
+    init_sqlite_adapter_better_sqlite3();
+  }
+});
+
+// src/runtime/store-sql/v0.19-sqlite/sqlite-ensure-version.ts
+async function ensureSQLiteVersion(url, dbConn) {
+  const version = await once.once(async () => {
+    const logger = ensureLogger(dbConn.opts, "ensureSQLiteVersion", {
+      version: SQLITE_VERSION,
+      url: dbConn.url.toString()
+    });
+    await dbConn.client.prepare(
+      `CREATE TABLE IF NOT EXISTS version (
+          version TEXT NOT NULL,
+          updated_at TEXT NOT NULL)`
+    ).run();
+    const rows = await dbConn.client.prepare(`select version from version`).all();
+    if (rows.length > 1) {
+      throw logger.Error().Msg(`more than one version row found`).AsError();
+    }
+    if (rows.length === 0) {
+      await dbConn.client.prepare(`insert into version (version, updated_at) values (?, ?)`).run(SQLITE_VERSION, (/* @__PURE__ */ new Date()).toISOString());
+      return SQLITE_VERSION;
+    }
+    if (rows[0].version !== SQLITE_VERSION) {
+      logger.Warn().Any("row", rows[0]).Msg(`version mismatch`);
+    }
+    return rows[0].version;
+  });
+  url.searchParams.set("version", version);
+}
+var import_cement9, once;
+var init_sqlite_ensure_version = __esm({
+  "src/runtime/store-sql/v0.19-sqlite/sqlite-ensure-version.ts"() {
+    "use strict";
+    init_version();
+    import_cement9 = require("@adviser/cement");
+    init_utils();
+    once = new import_cement9.ResolveOnce();
+  }
+});
+
+// src/runtime/store-sql/v0.19-sqlite/sqlite-wal-store.ts
+var sqlite_wal_store_exports = {};
+__export(sqlite_wal_store_exports, {
+  V0_18_0SQLiteWalStore: () => V0_18_0SQLiteWalStore,
+  WalSQLRecordBuilder: () => WalSQLRecordBuilder
+});
+var import_cement10, WalSQLRecordBuilder, V0_18_0SQLiteWalStore;
+var init_sqlite_wal_store = __esm({
+  "src/runtime/store-sql/v0.19-sqlite/sqlite-wal-store.ts"() {
+    "use strict";
+    import_cement10 = require("@adviser/cement");
+    init_sqlite_ensure_version();
+    init_utils();
+    WalSQLRecordBuilder = class _WalSQLRecordBuilder {
+      #record;
+      constructor(record) {
+        this.#record = record;
+      }
+      static fromRecord(record) {
+        return new _WalSQLRecordBuilder(record);
+      }
+      build() {
+        return this.#record;
+      }
+    };
+    V0_18_0SQLiteWalStore = class {
+      constructor(dbConn) {
+        this.dbConn = dbConn;
+        this.textEncoder = dbConn.opts.textEncoder;
+        this.logger = ensureLogger(dbConn.opts, "SQLiteWalStore");
+        this.logger.Debug().Msg("constructor");
+      }
+      async start(url) {
+        this.logger.Debug().Msg("start");
+        await this.dbConn.connect();
+        await ensureSQLiteVersion(url, this.dbConn);
+      }
+      table(url) {
+        return getStore(url, this.logger, (...x) => x.join("_"));
+      }
+      #createTable = new import_cement10.KeyedResolvOnce();
+      async createTable(url) {
+        return this.#createTable.get(this.table(url)).once(async (table) => {
+          await this.dbConn.client.prepare(
+            `CREATE TABLE IF NOT EXISTS ${table} (
+            name TEXT not null,
+            branch TEXT not null,
+            state BLOB NOT NULL,
+            updated_at TEXT NOT NULL,
+            PRIMARY KEY (name, branch)
+        )`
+          ).run();
+        });
+      }
+      #insertStmt = new import_cement10.KeyedResolvOnce();
+      async insertStmt(url) {
+        return this.#insertStmt.get(this.table(url)).once(async (table) => {
+          await this.createTable(url);
+          return this.dbConn.client.prepare(`insert into ${table}
+      (name, branch, state, updated_at)
+      values (?, ?, ?, ?)
+      ON CONFLICT(name, branch) DO UPDATE SET state=?, updated_at=?
+      `);
+        });
+      }
+      #selectStmt = new import_cement10.KeyedResolvOnce();
+      async selectStmt(url) {
+        return this.#selectStmt.get(this.table(url)).once(async (table) => {
+          await this.createTable(url);
+          return this.dbConn.client.prepare(
+            `select name, branch, state, updated_at from ${table}
+         where name = ? and branch = ?`
+          );
+        });
+      }
+      #deleteStmt = new import_cement10.KeyedResolvOnce();
+      async deleteStmt(url) {
+        return this.#deleteStmt.get(this.table(url)).once(async (table) => {
+          await this.createTable(url);
+          return this.dbConn.client.prepare(`delete from ${table} where name = ? and branch = ?`);
+        });
+      }
+      async insert(url, ose) {
+        const wal = WalSQLRecordBuilder.fromRecord(ose).build();
+        const bufState = Buffer.from(this.textEncoder.encode(JSON.stringify(wal.state)));
+        return this.insertStmt(url).then(
+          (i) => i.run(ose.name, ose.branch, bufState, wal.updated_at.toISOString(), bufState, wal.updated_at.toISOString())
+        );
+      }
+      async select(url, key) {
+        const res = (await this.selectStmt(url).then((i) => i.all(key.name, key.branch))).map((irow) => {
+          const row = irow;
+          return {
+            name: row.name,
+            branch: row.branch,
+            state: Uint8Array.from(row.state),
+            updated_at: new Date(row.updated_at)
+          };
+        });
+        this.logger.Debug().Str("name", key.name).Str("branch", key.branch).Uint64("res", res.length).Msg("select");
+        return res;
+      }
+      async delete(url, key) {
+        this.logger.Debug().Str("name", key.name).Str("branch", key.branch).Msg("delete");
+        return this.deleteStmt(url).then((i) => i.run(key.name, key.branch));
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async close(url) {
+        this.logger.Debug().Msg("close");
+        return import_cement10.Result.Ok(void 0);
+      }
+      async destroy(url) {
+        return exception2Result(async () => {
+          this.logger.Debug().Msg("destroy");
+          await this.createTable(url);
+          await this.dbConn.client.prepare(`delete from ${this.table(url)}`).run();
+        });
+      }
+    };
+  }
+});
+
+// src/runtime/store-sql/v0.19-sqlite/sqlite-data-store.ts
+var sqlite_data_store_exports = {};
+__export(sqlite_data_store_exports, {
+  DataSQLRecordBuilder: () => DataSQLRecordBuilder,
+  V0_18_0SQLiteDataStore: () => V0_18_0SQLiteDataStore
+});
+var import_cement11, DataSQLRecordBuilder, V0_18_0SQLiteDataStore;
+var init_sqlite_data_store = __esm({
+  "src/runtime/store-sql/v0.19-sqlite/sqlite-data-store.ts"() {
+    "use strict";
+    import_cement11 = require("@adviser/cement");
+    init_sqlite_ensure_version();
+    init_utils();
+    DataSQLRecordBuilder = class _DataSQLRecordBuilder {
+      constructor(dataRecord) {
+        this.dataRecord = dataRecord;
+      }
+      static fromUploadParams(data, params) {
+        return new _DataSQLRecordBuilder({
+          name: params.name,
+          car: params.car,
+          data,
+          updated_at: /* @__PURE__ */ new Date()
+        });
+      }
+      build() {
+        return this.dataRecord;
+      }
+    };
+    V0_18_0SQLiteDataStore = class {
+      constructor(dbConn) {
+        this.dbConn = dbConn;
+        this.logger = ensureLogger(dbConn.opts, "SQLiteDataStore");
+        this.logger.Debug().Msg("constructor");
+      }
+      table(url) {
+        return getStore(url, this.logger, (...x) => x.join("_"));
+      }
+      #createTable = new import_cement11.KeyedResolvOnce();
+      async createTable(url) {
+        return this.#createTable.get(this.table(url)).once(async (table) => {
+          await this.dbConn.client.prepare(
+            `CREATE TABLE IF NOT EXISTS ${table} (
+            name TEXT NOT NULL,
+            car TEXT PRIMARY KEY,
+            data BLOB NOT NULL,
+            updated_at TEXT NOT NULL)`
+          ).run();
+        });
+      }
+      #insertStmt = new import_cement11.KeyedResolvOnce();
+      async insertStmt(url) {
+        return this.#insertStmt.get(this.table(url)).once(async (table) => {
+          await this.createTable(url);
+          return this.dbConn.client.prepare(`
+        insert into ${table}
+          (name, car, data, updated_at) values (?, ?, ?, ?)
+          ON CONFLICT(car) DO UPDATE SET updated_at=?`);
+        });
+      }
+      #selectStmt = new import_cement11.KeyedResolvOnce();
+      async selectStmt(url) {
+        return this.#selectStmt.get(this.table(url)).once(async (table) => {
+          await this.createTable(url);
+          return this.dbConn.client.prepare(`select name, car, data, updated_at from ${table} where car = ?`);
+        });
+      }
+      #deleteStmt = new import_cement11.KeyedResolvOnce();
+      async deleteStmt(url) {
+        return this.#deleteStmt.get(this.table(url)).once(async (table) => {
+          await this.createTable(url);
+          return this.dbConn.client.prepare(`delete from ${table} where car = ?`);
+        });
+      }
+      async start(url) {
+        this.logger.Debug().Msg("start-connect");
+        await this.dbConn.connect();
+        this.logger.Debug().Msg("start-connected");
+        await ensureSQLiteVersion(url, this.dbConn);
+        this.logger.Debug().Msg("start-set-version");
+      }
+      async insert(url, ose) {
+        this.logger.Debug().Str("name", ose.name).Str("car", ose.car).Uint64("data-len", ose.data.length).Msg("insert");
+        const updated_at = ose.updated_at.toISOString();
+        return this.insertStmt(url).then((i) => i.run(ose.name, ose.car, Buffer.from(ose.data), updated_at, updated_at));
+      }
+      async select(url, car) {
+        this.logger.Debug().Str("car", car).Msg("select");
+        return (await this.selectStmt(url).then((i) => i.all(car))).map((irow) => {
+          const row = irow;
+          return {
+            name: row.name,
+            car: row.car,
+            data: Uint8Array.from(row.data),
+            updated_at: new Date(row.updated_at)
+          };
+        });
+      }
+      async delete(url, car) {
+        this.logger.Debug().Str("car", car).Msg("delete");
+        const ret = await this.deleteStmt(url).then((i) => i.run(car));
+        return ret;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async close(url) {
+        this.logger.Debug().Msg("close");
+        return import_cement11.Result.Ok(void 0);
+      }
+      async destroy(url) {
+        return exception2Result(async () => {
+          this.logger.Debug().Msg("destroy");
+          await this.createTable(url);
+          await this.dbConn.client.prepare(`delete from ${this.table(url)}`).run();
+        });
+      }
+    };
+  }
+});
+
+// src/runtime/store-sql/v0.19-sqlite/sqlite-meta-store.ts
+var sqlite_meta_store_exports = {};
+__export(sqlite_meta_store_exports, {
+  MetaSQLRecordBuilder: () => MetaSQLRecordBuilder,
+  V0_18_0SQLiteMetaStore: () => V0_18_0SQLiteMetaStore
+});
+var import_cement12, MetaSQLRecordBuilder, V0_18_0SQLiteMetaStore;
+var init_sqlite_meta_store = __esm({
+  "src/runtime/store-sql/v0.19-sqlite/sqlite-meta-store.ts"() {
+    "use strict";
+    import_cement12 = require("@adviser/cement");
+    init_sqlite_ensure_version();
+    init_utils();
+    MetaSQLRecordBuilder = class _MetaSQLRecordBuilder {
+      constructor(record, textEncoder3) {
+        this.record = record;
+        this.textEncoder = textEncoder3;
+      }
+      static fromUploadMetaFnParams(data, params, textEncoder3) {
+        return new _MetaSQLRecordBuilder(
+          {
+            name: params.name,
+            branch: params.branch,
+            meta: data,
+            updated_at: /* @__PURE__ */ new Date()
+          },
+          textEncoder3
+        );
+      }
+      static fromBytes(str, name, branch, textEncoder3) {
+        return new _MetaSQLRecordBuilder(
+          {
+            name,
+            branch,
+            meta: textEncoder3.encode(str),
+            updated_at: /* @__PURE__ */ new Date()
+          },
+          textEncoder3
+        );
+      }
+      build() {
+        return this.record;
+      }
+    };
+    V0_18_0SQLiteMetaStore = class {
+      constructor(dbConn) {
+        this.dbConn = dbConn;
+        this.logger = ensureLogger(dbConn.opts, "SQLiteMetaStore");
+        this.logger.Debug().Msg("constructor");
+      }
+      async start(url) {
+        this.logger.Debug().Url(url).Msg("starting");
+        await this.dbConn.connect();
+        await ensureSQLiteVersion(url, this.dbConn);
+        this.logger.Debug().Url(url).Msg("started");
+      }
+      table(url) {
+        return getStore(url, this.logger, (...x) => x.join("_"));
+      }
+      #createTable = new import_cement12.KeyedResolvOnce();
+      async createTable(url) {
+        return this.#createTable.get(this.table(url)).once(async (table) => {
+          await this.dbConn.client.prepare(
+            `CREATE TABLE IF NOT EXISTS ${table} (
+            name TEXT not null,
+            branch TEXT not null,
+            meta BLOB NOT NULL,
+            updated_at TEXT NOT NULL,
+            PRIMARY KEY (name, branch)
+            )`
+          ).run();
+        });
+      }
+      #insertStmt = new import_cement12.KeyedResolvOnce();
+      async insertStmt(url) {
+        return this.#insertStmt.get(this.table(url)).once(async (table) => {
+          await this.createTable(url);
+          return this.dbConn.client.prepare(`insert into ${table}
+          (name, branch, meta, updated_at)
+          values (?, ?, ?, ?)
+          ON CONFLICT(name, branch) DO UPDATE SET meta=?, updated_at=?
+          `);
+        });
+      }
+      #selectStmt = new import_cement12.KeyedResolvOnce();
+      async selectStmt(url) {
+        return this.#selectStmt.get(this.table(url)).once(async (table) => {
+          await this.createTable(url);
+          return this.dbConn.client.prepare(`select name, branch, meta, updated_at from ${table} where name = ? and branch = ?`);
+        });
+      }
+      #deleteStmt = new import_cement12.KeyedResolvOnce();
+      async deleteStmt(url) {
+        return this.#deleteStmt.get(this.table(url)).once(async (table) => {
+          await this.createTable(url);
+          return this.dbConn.client.prepare(`delete from ${table} where name = ? and branch = ?`);
+        });
+      }
+      async insert(url, ose) {
+        this.logger.Debug().Str("name", ose.name).Str("branch", ose.branch).Uint64("data-len", ose.meta.length).Msg("insert");
+        const bufMeta = Buffer.from(ose.meta);
+        return this.insertStmt(url).then(
+          (i) => i.run(ose.name, ose.branch, bufMeta, ose.updated_at.toISOString(), bufMeta, ose.updated_at.toISOString())
+        );
+      }
+      async select(url, key) {
+        this.logger.Debug().Str("name", key.name).Str("branch", key.branch).Msg("select");
+        return (await this.selectStmt(url).then((i) => i.all(key.name, key.branch))).map((irow) => {
+          const row = irow;
+          return {
+            name: row.name,
+            branch: row.branch,
+            meta: Uint8Array.from(row.meta),
+            updated_at: new Date(row.updated_at)
+          };
+        });
+      }
+      async delete(url, key) {
+        this.logger.Debug().Str("name", key.name).Str("branch", key.branch).Msg("delete");
+        return this.deleteStmt(url).then((i) => i.run(key.name, key.branch));
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      async close(url) {
+        this.logger.Debug().Msg("close");
+        return import_cement12.Result.Ok(void 0);
+      }
+      async destroy(url) {
+        return exception2Result(async () => {
+          this.logger.Debug().Msg("destroy");
+          await this.dbConn.client.prepare(`delete from ${this.table(url)}`).run();
+        });
+      }
+    };
+  }
+});
+
+// src/runtime/store-sql/store-version-factory.ts
+async function WalStoreFactory(db) {
+  switch (db.opts.sqlFlavor) {
+    case "sqlite": {
+      const { V0_18_0SQLiteWalStore: V0_18_0SQLiteWalStore2 } = await Promise.resolve().then(() => (init_sqlite_wal_store(), sqlite_wal_store_exports));
+      const store = new V0_18_0SQLiteWalStore2(db);
+      return store;
+    }
+    default:
+      throw ensureLogger(db.opts, "WalStoreFactory").Error().Msg("unsupported db connection").AsError();
+  }
+}
+async function DataStoreFactory(db) {
+  switch (db.opts.sqlFlavor) {
+    case "sqlite": {
+      const { V0_18_0SQLiteDataStore: V0_18_0SQLiteDataStore2 } = await Promise.resolve().then(() => (init_sqlite_data_store(), sqlite_data_store_exports));
+      const store = new V0_18_0SQLiteDataStore2(db);
+      return store;
+    }
+    default:
+      throw ensureLogger(db.opts, "DataStoreFactory").Error().Msg("unsupported db connection").AsError();
+  }
+}
+async function MetaStoreFactory(db) {
+  switch (db.opts.sqlFlavor) {
+    case "sqlite": {
+      const { V0_18_0SQLiteMetaStore: V0_18_0SQLiteMetaStore2 } = await Promise.resolve().then(() => (init_sqlite_meta_store(), sqlite_meta_store_exports));
+      const store = new V0_18_0SQLiteMetaStore2(db);
+      return store;
+    }
+    default:
+      throw ensureLogger(db.opts, "MetaStoreFactory").Error().Msg("unsupported db connection").AsError();
+  }
+}
+var init_store_version_factory = __esm({
+  "src/runtime/store-sql/store-version-factory.ts"() {
+    "use strict";
+    init_utils();
+    init_version();
+  }
+});
+
+// src/runtime/store-sql/store-sql.ts
+var store_sql_exports2 = {};
+__export(store_sql_exports2, {
+  SQLDataGateway: () => SQLDataGateway,
+  SQLMetaGateway: () => SQLMetaGateway,
+  SQLTestStore: () => SQLTestStore,
+  SQLWalGateway: () => SQLWalGateway
+});
+var import_cement13, SQLWalGateway, SQLMetaGateway, SQLDataGateway, SQLTestStore;
+var init_store_sql2 = __esm({
+  "src/runtime/store-sql/store-sql.ts"() {
+    "use strict";
+    import_cement13 = require("@adviser/cement");
+    init_sql_connection_factory();
+    init_store_version_factory();
+    init_utils();
+    init_gateway();
+    SQLWalGateway = class {
+      constructor(logger) {
+        this.walSQLStore = {};
+        this.logger = ensureLogger(logger, "SQLWalGateway");
+      }
+      buildUrl(baseUrl, key) {
+        const url = new URL(baseUrl.toString());
+        url.searchParams.set("key", key);
+        return Promise.resolve(import_cement13.Result.Ok(url));
+      }
+      async start(baseUrl) {
+        return exception2Result(async () => {
+          this.logger.Debug().Url(baseUrl).Msg("start");
+          const conn = SQLConnectionFactory(baseUrl);
+          const ws = await WalStoreFactory(conn);
+          await ws.start(baseUrl);
+          this.walSQLStore = ws;
+        });
+      }
+      close(baseUrl) {
+        return this.walSQLStore.close(baseUrl);
+      }
+      destroy(baseUrl) {
+        return this.walSQLStore.destroy(baseUrl);
+      }
+      async put(url, body) {
+        return exception2Result(async () => {
+          const branch = getKey(url, this.logger);
+          const name = getName(url, this.logger);
+          await this.walSQLStore.insert(url, {
+            state: body,
+            updated_at: /* @__PURE__ */ new Date(),
+            name,
+            branch
+          });
+        });
+      }
+      async get(url) {
+        return exceptionWrapper(async () => {
+          const branch = getKey(url, this.logger);
+          const name = getName(url, this.logger);
+          const record = await this.walSQLStore.select(url, { name, branch });
+          if (record.length === 0) {
+            return import_cement13.Result.Err(new NotFoundError(`not found ${name} ${branch}`));
+          }
+          return import_cement13.Result.Ok(record[0].state);
+        });
+      }
+      async delete(url) {
+        return exception2Result(async () => {
+          const branch = getKey(url, this.logger);
+          const name = getName(url, this.logger);
+          await this.walSQLStore.delete(url, { name, branch });
+        });
+      }
+    };
+    SQLMetaGateway = class {
+      constructor(logger) {
+        this.metaSQLStore = {};
+        this.logger = ensureLogger(logger, "SQLMetaGateway");
+      }
+      buildUrl(baseUrl, key) {
+        const url = new URL(baseUrl.toString());
+        url.searchParams.set("key", key);
+        return Promise.resolve(import_cement13.Result.Ok(url));
+      }
+      async start(baseUrl) {
+        return exception2Result(async () => {
+          this.logger.Debug().Url(baseUrl).Msg("start");
+          const conn = SQLConnectionFactory(baseUrl);
+          const ws = await MetaStoreFactory(conn);
+          await ws.start(baseUrl);
+          this.metaSQLStore = ws;
+          this.logger.Debug().Url(baseUrl).Msg("started");
+        });
+      }
+      close(baseUrl) {
+        return this.metaSQLStore.close(baseUrl);
+      }
+      destroy(baseUrl) {
+        return this.metaSQLStore.destroy(baseUrl);
+      }
+      async put(url, body) {
+        return exception2Result(async () => {
+          const branch = getKey(url, this.logger);
+          const name = getName(url, this.logger);
+          await this.metaSQLStore.insert(url, {
+            meta: body,
+            updated_at: /* @__PURE__ */ new Date(),
+            name,
+            branch
+          });
+        });
+      }
+      async get(url) {
+        return exceptionWrapper(async () => {
+          const branch = getKey(url, this.logger);
+          const name = getName(url, this.logger);
+          const record = await this.metaSQLStore.select(url, {
+            name,
+            branch
+          });
+          if (record.length === 0) {
+            return import_cement13.Result.Err(new NotFoundError(`not found ${name} ${branch}`));
+          }
+          return import_cement13.Result.Ok(record[0].meta);
+        });
+      }
+      async delete(url) {
+        return exception2Result(async () => {
+          const branch = getKey(url, this.logger);
+          const name = getName(url, this.logger);
+          await this.metaSQLStore.delete(url, {
+            name,
+            branch
+          });
+        });
+      }
+    };
+    SQLDataGateway = class {
+      constructor(logger) {
+        this.dataSQLStore = {};
+        this.logger = ensureLogger(logger, "SQLDataGateway");
+      }
+      buildUrl(baseUrl, key) {
+        const url = new URL(baseUrl.toString());
+        url.searchParams.set("key", key);
+        return Promise.resolve(import_cement13.Result.Ok(url));
+      }
+      async start(baseUrl) {
+        return exception2Result(async () => {
+          this.logger.Debug().Url(baseUrl).Msg("pre-sql-connection");
+          const conn = SQLConnectionFactory(baseUrl);
+          this.logger.Debug().Url(baseUrl).Msg("post-sql-connection");
+          const ws = await DataStoreFactory(conn);
+          this.logger.Debug().Url(baseUrl).Msg("post-data-store-factory");
+          await ws.start(baseUrl);
+          this.dataSQLStore = ws;
+          this.logger.Debug().Url(baseUrl).Msg("started");
+        });
+      }
+      close(baseUrl) {
+        return this.dataSQLStore.close(baseUrl);
+      }
+      destroy(baseUrl) {
+        return this.dataSQLStore.destroy(baseUrl);
+      }
+      async put(url, body) {
+        return exception2Result(async () => {
+          const cid = getKey(url, this.logger);
+          const name = getName(url, this.logger);
+          await this.dataSQLStore.insert(url, {
+            data: body,
+            updated_at: /* @__PURE__ */ new Date(),
+            name,
+            car: cid
+          });
+        });
+      }
+      async get(url) {
+        return exceptionWrapper(async () => {
+          const branch = getKey(url, this.logger);
+          const record = await this.dataSQLStore.select(url, branch);
+          if (record.length === 0) {
+            return import_cement13.Result.Err(new NotFoundError(`not found ${branch}`));
+          }
+          return import_cement13.Result.Ok(record[0].data);
+        });
+      }
+      async delete(url) {
+        return exception2Result(async () => {
+          const branch = getKey(url, this.logger);
+          await this.dataSQLStore.delete(url, branch);
+          return import_cement13.Result.Ok(void 0);
+        });
+      }
+    };
+    SQLTestStore = class {
+      constructor(ilogger) {
+        const logger = ensureLogger(ilogger, "SQLTestStore");
+        this.logger = logger;
+      }
+      async get(url, key) {
+        const conn = SQLConnectionFactory(url);
+        const name = getName(url, this.logger);
+        switch (url.searchParams.get("store")) {
+          case "wal": {
+            const sqlStore = await WalStoreFactory(conn);
+            await sqlStore.start(url);
+            const records = await sqlStore.select(url, {
+              name,
+              branch: key
+            });
+            return records[0].state;
+          }
+          case "meta": {
+            const sqlStore = await MetaStoreFactory(conn);
+            await sqlStore.start(url);
+            const records = await sqlStore.select(url, {
+              name,
+              branch: key
+            });
+            return records[0].meta;
+          }
+          case "data": {
+            const sqlStore = await DataStoreFactory(conn);
+            await sqlStore.start(url);
+            const records = await sqlStore.select(url, key);
+            return records[0].data;
+          }
+          default:
+            throw this.logger.Error().Str("key", key).Msg(`Method not implemented`);
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CRDT: () => CRDT,
+  Database: () => Database,
+  Index: () => Index,
+  PACKAGE_VERSION: () => PACKAGE_VERSION,
+  blockstore: () => blockstore_exports,
+  bs: () => blockstore_exports,
+  ensureLogger: () => ensureLogger,
+  exception2Result: () => exception2Result,
+  exceptionWrapper: () => exceptionWrapper,
+  falsyToUndef: () => falsyToUndef,
+  fireproof: () => fireproof,
+  getKey: () => getKey,
+  getName: () => getName,
+  getStore: () => getStore,
+  index: () => index,
+  isFalsy: () => isFalsy,
+  rt: () => runtime_exports,
+  runtime: () => runtime_exports,
+  throwFalsy: () => throwFalsy
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/database.ts
+var import_uuidv73 = require("uuidv7");
+var import_cement17 = require("@adviser/cement");
+
+// src/write-queue.ts
+function writeQueue(worker, payload = Infinity, unbounded = false) {
+  const queue = [];
+  let isProcessing = false;
+  async function process() {
+    if (isProcessing || queue.length === 0) return;
+    isProcessing = true;
+    const tasksToProcess = queue.splice(0, payload);
+    const updates = tasksToProcess.map((item) => item.task);
+    if (unbounded) {
+      const promises = updates.map(async (update, index2) => {
+        try {
+          const result = await worker([update]);
+          tasksToProcess[index2].resolve(result);
+        } catch (error) {
+          tasksToProcess[index2].reject(error);
+        }
+      });
+      await Promise.all(promises);
+    } else {
+      try {
+        const result = await worker(updates);
+        tasksToProcess.forEach((task) => task.resolve(result));
+      } catch (error) {
+        tasksToProcess.forEach((task) => task.reject(error));
+      }
+    }
+    isProcessing = false;
+    void process();
+  }
+  return {
+    push(task) {
+      return new Promise((resolve, reject) => {
+        queue.push({ task, resolve, reject });
+        void process();
+      });
+    }
+  };
+}
+
+// src/crdt.ts
+var import_cement16 = require("@adviser/cement");
+
+// 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_crdt = require("@web3-storage/pail/crdt");
+var import_clock2 = require("@web3-storage/pail/clock");
+var Batch = __toESM(require("@web3-storage/pail/crdt/batch"), 1);
+
+// src/blockstore/index.ts
+var blockstore_exports = {};
+__export(blockstore_exports, {
+  BaseBlockstore: () => BaseBlockstore,
+  CarTransaction: () => CarTransaction,
+  CompactionFetcher: () => CompactionFetcher,
+  ConnectREST: () => ConnectREST,
+  ConnectionBase: () => ConnectionBase,
+  DataStore: () => DataStore,
+  EncryptedBlockstore: () => EncryptedBlockstore,
+  Loadable: () => Loadable,
+  Loader: () => Loader,
+  MetaStore: () => MetaStore,
+  NotFoundError: () => NotFoundError,
+  RemoteWAL: () => RemoteWAL,
+  isNotFoundError: () => isNotFoundError,
+  parseCarFile: () => parseCarFile,
+  registerStoreProtocol: () => registerStoreProtocol,
+  testStoreFactory: () => testStoreFactory,
+  toStoreRuntime: () => toStoreRuntime,
+  toURL: () => toURL
+});
+
+// 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/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/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");
+  }
+  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/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;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async metaUpload(bytes, params) {
+    return void 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async metaDownload(params) {
+    return [];
+  }
+};
+
+// src/blockstore/store-factory.ts
+var import_cement14 = require("@adviser/cement");
+init_data_dir();
+
+// src/runtime/files.ts
+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);
+  }
+  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);
+        }
+      })
+    );
+    return await unixfsFileWriter.close();
+  }
+};
+
+// src/blockstore/store.ts
+var import_p_limit2 = __toESM(require("p-limit"), 1);
+var import_dag_json = require("@ipld/dag-json");
+var import_cement6 = require("@adviser/cement");
+init_types();
+init_gateway();
+init_utils();
+init_store_indexdb();
+
+// src/blockstore/loader.ts
+var import_p_limit = __toESM(require("p-limit"), 1);
+var import_car = require("@ipld/car");
+var import_cement5 = require("@adviser/cement");
+
+// src/blockstore/types.ts
+function toCIDBlock(block) {
+  return block;
+}
+
+// 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
+  });
+}
+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;
+  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_utils8 = 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_utils8.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();
+
+// src/runtime/crypto.ts
+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;
+}
+
+// src/blockstore/transaction.ts
+init_utils();
+var CarTransaction = class extends import_block5.MemoryBlockstore {
+  constructor(parent, opts = { add: true }) {
+    super();
+    if (opts.add) {
+      parent.transactions.add(this);
+    }
+    this.parent = parent;
+  }
+  async get(cid) {
+    return await this.superGet(cid) || falsyToUndef(await this.parent.get(cid));
+  }
+  async superGet(cid) {
+    return super.get(cid);
+  }
+};
+function defaultedBlockstoreRuntime(opts, component, ctx) {
+  const logger = ensureLogger(opts, component, ctx);
+  const store = opts.store || {};
+  return {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    applyMeta: (meta, snap) => {
+      return Promise.resolve();
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    compact: async (blocks) => {
+      return {};
+    },
+    autoCompact: 100,
+    public: false,
+    name: void 0,
+    threshold: 1e3 * 1e3,
+    ...opts,
+    logger,
+    crypto: toCryptoOpts(opts.crypto),
+    store,
+    storeRuntime: toStoreRuntime(store, logger)
+  };
+}
+var blockstoreFactory = function(opts) {
+  if (opts.name) {
+    return new EncryptedBlockstore(opts);
+  } else {
+    return new BaseBlockstore(opts);
+  }
+};
+var BaseBlockstore = class {
+  constructor(ebOpts = {}) {
+    this.transactions = /* @__PURE__ */ new Set();
+    this.ebOpts = defaultedBlockstoreRuntime(ebOpts, "BaseBlockstore");
+    this.logger = this.ebOpts.logger;
+  }
+  // ready: Promise<void>;
+  ready() {
+    return Promise.resolve();
+  }
+  async close() {
+  }
+  async destroy() {
+  }
+  async get(cid) {
+    if (!cid) throw this.logger.Error().Msg("required cid").AsError();
+    for (const f of this.transactions) {
+      const v = await f.superGet(cid);
+      if (v) return v;
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async put(cid, block) {
+    throw this.logger.Error().Msg("use a transaction to put").AsError();
+  }
+  // TransactionMeta
+  async transaction(fn, _opts = {}) {
+    const t = new CarTransaction(this);
+    const done = await fn(t);
+    this.lastTxMeta = done;
+    return { t, meta: done };
+  }
+  async *entries() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of this.transactions) {
+      for await (const blk of t.entries()) {
+        if (seen.has(blk.cid.toString())) continue;
+        seen.add(blk.cid.toString());
+        yield blk;
+      }
+    }
+  }
+};
+var EncryptedBlockstore = class extends BaseBlockstore {
+  constructor(ebOpts) {
+    super(ebOpts);
+    this.compacting = false;
+    this.logger = ensureLogger(ebOpts, "EncryptedBlockstore");
+    const { name } = ebOpts;
+    if (!name) {
+      throw this.logger.Error().Msg("name required").AsError();
+    }
+    this.name = name;
+    this.loader = new Loader(this.name, ebOpts);
+  }
+  ready() {
+    return this.loader.ready();
+  }
+  close() {
+    return this.loader.close();
+  }
+  destroy() {
+    return this.loader.destroy();
+  }
+  async get(cid) {
+    const got = await super.get(cid);
+    if (got) return got;
+    if (!this.loader) {
+      return;
+    }
+    return falsyToUndef(await this.loader.getBlock(cid));
+  }
+  async transaction(fn, opts = { noLoader: false }) {
+    const { t, meta: done } = await super.transaction(fn);
+    const cars = await this.loader.commit(t, done, opts);
+    if (this.ebOpts.autoCompact && this.loader.carLog.length > this.ebOpts.autoCompact) {
+      setTimeout(() => void this.compact(), 10);
+    }
+    if (cars) {
+      this.transactions.delete(t);
+      return { meta: done, cars, t };
+    }
+    throw this.logger.Error().Msg("failed to commit car files").AsError();
+  }
+  async getFile(car, cid, isPublic = false) {
+    await this.ready();
+    if (!this.loader) throw this.logger.Error().Msg("loader required to get file, database must be named").AsError();
+    const reader = await this.loader.loadFileCar(car, isPublic);
+    const block = await reader.get(cid);
+    if (!block) throw this.logger.Error().Str("cid", cid.toString()).Msg(`Missing block`).AsError();
+    return block.bytes;
+  }
+  async compact() {
+    await this.ready();
+    if (!this.loader) throw this.logger.Error().Msg("loader required to compact").AsError();
+    if (this.loader.carLog.length < 2) return;
+    const compactFn = this.ebOpts.compact || ((blocks) => this.defaultCompact(blocks, this.logger));
+    if (!compactFn || this.compacting) return;
+    const blockLog = new CompactionFetcher(this);
+    this.compacting = true;
+    const meta = await compactFn(blockLog);
+    await this.loader?.commit(blockLog.loggedBlocks, meta, {
+      compact: true,
+      noLoader: true
+    });
+    this.compacting = false;
+  }
+  async defaultCompact(blocks, logger) {
+    if (!this.loader) {
+      throw logger.Error().Msg("no loader").AsError();
+    }
+    if (!this.lastTxMeta) {
+      throw logger.Error().Msg("no lastTxMeta").AsError();
+    }
+    for await (const blk of this.loader.entries(false)) {
+      blocks.loggedBlocks.putSync(blk.cid, blk.bytes);
+    }
+    for (const t of this.transactions) {
+      for await (const blk of t.entries()) {
+        blocks.loggedBlocks.putSync(blk.cid, blk.bytes);
+      }
+    }
+    return this.lastTxMeta;
+  }
+  async *entries() {
+    for await (const blk of this.loader.entries()) {
+      yield blk;
+    }
+  }
+};
+var CompactionFetcher = class {
+  constructor(blocks) {
+    this.blockstore = blocks;
+    this.loggedBlocks = new CarTransaction(blocks);
+  }
+  async get(cid) {
+    const block = await this.blockstore.get(cid);
+    if (block) this.loggedBlocks.putSync(cid, block.bytes);
+    return falsyToUndef(block);
+  }
+};
+
+// src/blockstore/commit-queue.ts
+var CommitQueue = class {
+  constructor() {
+    this.queue = [];
+    this.processing = false;
+  }
+  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();
+      }
+    }
+  }
+};
+
+// src/blockstore/loader.ts
+var CBW2 = __toESM(require("@ipld/car/buffer-writer"), 1);
+function carLogIncludesGroup2(list, cids) {
+  return list.some((arr) => {
+    return arr.toString() === cids.toString();
+  });
+}
+function uniqueCids(list, remove = /* @__PURE__ */ new Set()) {
+  const byString = /* @__PURE__ */ new Map();
+  for (const cid of list) {
+    if (remove.has(cid.toString())) continue;
+    byString.set(cid.toString(), cid);
+  }
+  return [...byString.values()];
+}
+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) {
+    this.commitQueue = new CommitQueue();
+    this.isCompacting = false;
+    this.carReaders = /* @__PURE__ */ new Map();
+    this.seenCompacted = /* @__PURE__ */ new Set();
+    this.processedCars = /* @__PURE__ */ new Set();
+    this.carLog = [];
+    this.getBlockCache = /* @__PURE__ */ new Map();
+    this.seenMeta = /* @__PURE__ */ new Set();
+    this.writeLimit = (0, import_p_limit.default)(1);
+    this.onceReady = new import_cement5.ResolveOnce();
+    this.name = name;
+    this.ebOpts = defaultedBlockstoreRuntime(
+      {
+        ...ebOpts,
+        name
+      },
+      "Loader"
+    );
+    this.logger = this.ebOpts.logger;
+  }
+  // readonly id = uuidv4();
+  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 metaStore() {
+    return this.ebOpts.storeRuntime.makeMetaStore(this);
+  }
+  async ready() {
+    return this.onceReady.once(async () => {
+      const metas = this.ebOpts.meta ? [this.ebOpts.meta] : await (await this.metaStore()).load("main");
+      if (metas) {
+        await this.handleDbMetasFromStore(metas);
+      }
+    });
+  }
+  async close() {
+    const toClose = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.remoteWAL()]);
+    await Promise.all(toClose.map((store) => store.close()));
+  }
+  async destroy() {
+    const toDestroy = await Promise.all([this.carStore(), this.metaStore(), this.fileStore(), this.remoteWAL()]);
+    await Promise.all(toDestroy.map((store) => store.destroy()));
+  }
+  // async snapToCar(carCid: AnyLink | string) {
+  //   await this.ready
+  //   if (typeof carCid === 'string') {
+  //     carCid = CID.parse(carCid)
+  //   }
+  //   const carHeader = await this.loadCarHeaderFromMeta({ car: carCid, key: this.key || null })
+  //   this.carLog = [carCid, ...carHeader.cars]
+  //   await this.getMoreReaders(carHeader.cars)
+  //   await this._applyCarHeader(carHeader, true)
+  // }
+  async handleDbMetasFromStore(metas) {
+    for (const meta of metas) {
+      await this.writeLimit(async () => {
+        await this.mergeDbMetaIntoClock(meta);
+      });
+    }
+  }
+  async mergeDbMetaIntoClock(meta) {
+    if (this.isCompacting) {
+      throw this.logger.Error().Msg("cannot merge while compacting").AsError();
+    }
+    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)) {
+      return;
+    }
+    const carHeader = await this.loadCarHeaderFromMeta(meta);
+    carHeader.compact.map((c) => c.toString()).forEach(this.seenCompacted.add, this.seenCompacted);
+    await this.getMoreReaders(carHeader.cars.flat());
+    this.carLog = [...uniqueCids([meta.cars, ...this.carLog, ...carHeader.cars], this.seenCompacted)];
+    await this.ebOpts.applyMeta?.(carHeader.meta);
+  }
+  async ingestKeyFromMeta(meta) {
+    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 }) {
+    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;
+  }
+  async loadFileCar(cid, isPublic = false) {
+    return await this.storesLoadCar(cid, await this.fileStore(), this.remoteFileStore, isPublic);
+  }
+  async commit(t, done, opts = { noLoader: false, compact: false }) {
+    return this.commitQueue.enqueue(() => this._commitInternal(t, done, opts));
+  }
+  async cacheTransaction(t) {
+    for await (const block of t.entries()) {
+      const sBlock = block.cid.toString();
+      if (!this.getBlockCache.has(sBlock)) {
+        this.getBlockCache.set(sBlock, block);
+      }
+    }
+  }
+  async cacheCarReader(carCidStr, reader) {
+    if (this.processedCars.has(carCidStr)) return;
+    this.processedCars.add(carCidStr);
+    for await (const block of reader.blocks()) {
+      const sBlock = block.cid.toString();
+      if (!this.getBlockCache.has(sBlock)) {
+        this.getBlockCache.set(sBlock, block);
+      }
+    }
+  }
+  async _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]
+    });
+    for (const cids of carHeader.compact) {
+      for (const cid2 of cids) {
+        await (await this.carStore()).remove(cid2);
+      }
+    }
+  }
+  // async flushCars() {
+  //   await this.ready
+  //   // for each cid in car log, make a dbMeta
+  //   for (const cid of this.carLog) {
+  //     const dbMeta = { car: cid, key: this.key || null } as DbMeta
+  //     await this.remoteWAL!.enqueue(dbMeta, { public: false })
+  //   }
+  // }
+  async *entries(cache3 = true) {
+    await this.ready();
+    if (cache3) {
+      for (const [, block] of this.getBlockCache) {
+        yield block;
+      }
+    } else {
+      for (const [, block] of this.getBlockCache) {
+        yield block;
+      }
+      for (const cids of this.carLog) {
+        for (const cid of cids) {
+          const reader = await this.loadCar(cid);
+          if (!reader) throw this.logger.Error().Ref("cid", cid).Msg("missing car reader").AsError();
+          for await (const block of reader.blocks()) {
+            const sCid = block.cid.toString();
+            if (!this.getBlockCache.has(sCid)) {
+              yield block;
+            }
+          }
+        }
+      }
+    }
+  }
+  async getBlock(cid) {
+    await this.ready();
+    const sCid = cid.toString();
+    if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
+    const getCarCid = async (carCid) => {
+      if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
+      const reader = await this.loadCar(carCid);
+      if (!reader) {
+        throw this.logger.Error().Ref("cid", carCid).Msg("missing car reader").AsError();
+      }
+      await this.cacheCarReader(carCid.toString(), reader).catch(() => {
+        return;
+      });
+      if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
+      throw this.logger.Error().Str("cid", sCid).Msg("block not in reader").AsError();
+    };
+    const getCompactCarCids = async (carCid) => {
+      const reader = await this.loadCar(carCid);
+      if (!reader) {
+        throw this.logger.Error().Str("cid", carCid.toString()).Msg("missing car reader").AsError();
+      }
+      const header = await parseCarFile(reader, this.logger);
+      const compacts = header.compact;
+      let got2;
+      const batchSize2 = 5;
+      for (let i = 0; i < compacts.length; i += batchSize2) {
+        const promises = [];
+        for (let j = i; j < Math.min(i + batchSize2, compacts.length); j++) {
+          for (const cid2 of compacts[j]) {
+            promises.push(getCarCid(cid2));
+          }
+        }
+        try {
+          got2 = await Promise.any(promises);
+        } catch {
+        }
+        if (got2) break;
+      }
+      if (this.getBlockCache.has(sCid)) return this.getBlockCache.get(sCid);
+      throw this.logger.Error().Str("cid", sCid).Msg("block not in compact reader").AsError();
+    };
+    let got;
+    const batchSize = 5;
+    for (let i = 0; i < this.carLog.length; i += batchSize) {
+      const batch = this.carLog.slice(i, i + batchSize);
+      const promises = batch.flatMap((slice) => slice.map(getCarCid));
+      try {
+        got = await Promise.any(promises);
+      } catch {
+      }
+      if (got) break;
+    }
+    if (!got) {
+      try {
+        got = await getCompactCarCids(this.carLog[this.carLog.length - 1][0]);
+      } catch {
+      }
+    }
+    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();
+    }
+    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) {
+    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;
+        })
+      );
+    }
+    return this.carReaders.get(cidsString);
+  }
+  async ensureDecryptedReader(reader) {
+    const theKey = await this._getKey();
+    if (this.ebOpts.public || !(theKey && this.ebOpts.crypto)) {
+      return reader;
+    }
+    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)
+    };
+  }
+  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("");
+  }
+  async getMoreReaders(cids) {
+    const limit = (0, import_p_limit.default)(5);
+    const missing = cids.filter((cid) => !this.carReaders.has(cid.toString()));
+    await Promise.all(missing.map((cid) => limit(() => this.loadCar(cid))));
+  }
+};
+
+// src/blockstore/store.ts
+var VersionedStore = class {
+  constructor(name, url, logger) {
+    this._onStarted = [];
+    this._onClosed = [];
+    this.name = name;
+    this.url = url;
+    this.logger = logger;
+  }
+  onStarted(fn) {
+    this._onStarted.push(fn);
+  }
+  onClosed(fn) {
+    this._onClosed.push(fn);
+  }
+};
+var textEncoder2 = new TextEncoder();
+var textDecoder2 = new TextDecoder();
+var MetaStore = class extends VersionedStore {
+  constructor(name, url, logger, gateway) {
+    super(name, url, ensureLogger(logger, "MetaStore", {}));
+    this.tag = "header-base";
+    this.gateway = gateway;
+  }
+  makeHeader({ cars, key }) {
+    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;
+    }
+    this._onStarted.forEach((fn) => fn());
+    return guardVersion(this.url);
+  }
+  async load(branch) {
+    this.logger.Debug().Str("branch", branch || "").Msg("loading");
+    const url = await this.gateway.buildUrl(this.url, branch || "main");
+    if (url.isErr()) {
+      throw this.logger.Error().Err(url.Err()).Str("branch", branch || "").Str("url", this.url.toString()).Msg("got error from gateway.buildUrl").AsError();
+    }
+    const bytes = await this.gateway.get(url.Ok());
+    if (bytes.isErr()) {
+      if (isNotFoundError(bytes)) {
+        return void 0;
+      }
+      throw this.logger.Error().Err(bytes.Err()).Msg("gateway get").AsError();
+    }
+    try {
+      return [this.parseHeader(textDecoder2.decode(bytes.Ok()))];
+    } catch (e) {
+      throw this.logger.Error().Err(e).Msg("parseHeader").AsError();
+    }
+  }
+  async save(meta, branch = "main") {
+    this.logger.Debug().Str("branch", branch).Any("meta", meta).Msg("saving meta");
+    const bytes = this.makeHeader(meta);
+    const url = await this.gateway.buildUrl(this.url, branch);
+    if (url.isErr()) {
+      throw this.logger.Error().Err(url.Err()).Str("branch", branch).Url(this.url).Msg("got error from gateway.buildUrl").AsError();
+    }
+    const res = await this.gateway.put(url.Ok(), textEncoder2.encode(bytes));
+    if (res.isErr()) {
+      throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
+    }
+    return res.Ok();
+  }
+  async close() {
+    await this.gateway.close(this.url);
+    this._onClosed.forEach((fn) => fn());
+    return import_cement6.Result.Ok(void 0);
+  }
+  async destroy() {
+    return this.gateway.destroy(this.url);
+  }
+};
+var DataStore = class extends VersionedStore {
+  constructor(name, url, logger, gateway) {
+    super(
+      name,
+      url,
+      ensureLogger(logger, "DataStore", {
+        url: () => url.toString()
+      })
+    );
+    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().Err(res.Err()).Msg("started-gateway");
+      return res;
+    }
+    this._onStarted.forEach((fn) => fn());
+    const version = guardVersion(this.url);
+    if (version.isErr()) {
+      this.logger.Error().Err(res.Err()).Msg("guardVersion");
+      await this.close();
+      return version;
+    }
+    this.logger.Debug().Msg("started");
+    return version;
+  }
+  async load(cid) {
+    this.logger.Debug().Any("cid", cid).Msg("loading");
+    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(url.Ok());
+    if (res.isErr()) {
+      throw res.Err();
+    }
+    return { cid, bytes: res.Ok() };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async save(car, opts) {
+    this.logger.Debug().Any("cid", car.cid.toString()).Msg("saving");
+    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(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 url = await this.gateway.buildUrl(this.url, cid.toString());
+    if (url.isErr()) {
+      return url;
+    }
+    return this.gateway.delete(url.Ok());
+  }
+  async close() {
+    await this.gateway.close(this.url);
+    this._onClosed.forEach((fn) => fn());
+    return import_cement6.Result.Ok(void 0);
+  }
+  destroy() {
+    return this.gateway.destroy(this.url);
+  }
+};
+var RemoteWAL = class extends VersionedStore {
+  constructor(loader, url, logger, gateway) {
+    super(loader.name, url, ensureLogger(logger, "RemoteWAL"));
+    this.tag = "rwal-base";
+    this._ready = new import_cement6.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;
+      });
+      if (!walState) {
+        this.walState.operations = [];
+        this.walState.fileOperations = [];
+      } else {
+        this.walState.operations = walState.operations || [];
+        this.walState.fileOperations = walState.fileOperations || [];
+      }
+    });
+  }
+  async enqueue(dbMeta, opts) {
+    await this.ready();
+    if (opts.noLoader) {
+      this.walState.noLoaderOps.push(dbMeta);
+    } else {
+      this.walState.operations.push(dbMeta);
+    }
+    await this.save(this.walState);
+    void this._process();
+  }
+  async enqueueFile(fileCid, publicFile = false) {
+    await this.ready();
+    this.walState.fileOperations.push({ cid: fileCid, public: publicFile });
+  }
+  async _process() {
+    await this.ready();
+    if (!this.loader.remoteCarStore) return;
+    await this.processQueue.enqueue(async () => {
+      await this._doProcess();
+      if (this.walState.operations.length || this.walState.fileOperations.length || this.walState.noLoaderOps.length) {
+        setTimeout(() => void this._process(), 0);
+      }
+    });
+  }
+  async _doProcess() {
+    if (!this.loader.remoteCarStore) return;
+    const rmlp = (async () => {
+      const operations = [...this.walState.operations];
+      const fileOperations = [...this.walState.fileOperations];
+      const uploads = [];
+      const noLoaderOps = [...this.walState.noLoaderOps];
+      const limit = (0, import_p_limit2.default)(5);
+      if (operations.length + fileOperations.length + noLoaderOps.length === 0) return;
+      for (const dbMeta of noLoaderOps) {
+        const uploadP = limit(async () => {
+          for (const cid of dbMeta.cars) {
+            const car = await (await this.loader.carStore()).load(cid);
+            if (!car) {
+              if (carLogIncludesGroup2(this.loader.carLog, dbMeta.cars))
+                throw this.logger.Error().Ref("cid", cid).Msg("missing local car").AsError();
+            } else {
+              await throwFalsy(this.loader.remoteCarStore).save(car);
+            }
+            this.walState.noLoaderOps = this.walState.noLoaderOps.filter((op) => op !== dbMeta);
+          }
+        });
+        uploads.push(uploadP);
+      }
+      for (const dbMeta of operations) {
+        const uploadP = limit(async () => {
+          for (const cid of dbMeta.cars) {
+            const car = await (await this.loader.carStore()).load(cid).catch(() => null);
+            if (!car) {
+              if (carLogIncludesGroup2(this.loader.carLog, dbMeta.cars))
+                throw this.logger.Error().Ref("cid", cid).Msg(`missing local car`).AsError();
+            } else {
+              await throwFalsy(this.loader.remoteCarStore).save(car);
+            }
+          }
+          this.walState.operations = this.walState.operations.filter((op) => op !== dbMeta);
+        });
+        uploads.push(uploadP);
+      }
+      if (fileOperations.length) {
+        const dbLoader = this.loader;
+        for (const { cid: fileCid, public: publicFile } of fileOperations) {
+          const uploadP = limit(async () => {
+            const fileBlock = await (await dbLoader.fileStore()).load(fileCid);
+            await dbLoader.remoteFileStore?.save(fileBlock, { public: publicFile });
+            this.walState.fileOperations = this.walState.fileOperations.filter((op) => op.cid !== fileCid);
+          });
+          uploads.push(uploadP);
+        }
+      }
+      try {
+        const res = await Promise.allSettled(uploads);
+        const errors = res.filter((r) => r.status === "rejected");
+        if (errors.length) {
+          throw this.logger.Error().Any(
+            "errors",
+            errors.map((e) => e.reason)
+          ).Msg("error uploading").AsError();
+          errors[0].reason;
+        }
+        if (operations.length) {
+          const lastOp = operations[operations.length - 1];
+          await this.loader.remoteMetaStore?.save(lastOp).catch((e) => {
+            this.walState.operations.push(lastOp);
+            throw this.logger.Error().Any("error", e).Msg("error saving remote meta").AsError();
+          });
+        }
+      } finally {
+        await this.save(this.walState);
+      }
+    })();
+    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");
+    if (filepath.isErr()) {
+      throw this.logger.Error().Err(filepath.Err()).Str("url", this.url.toString()).Msg("error building url").AsError();
+    }
+    const bytes = await this.gateway.get(filepath.Ok());
+    if (bytes.isErr()) {
+      if (isNotFoundError(bytes)) {
+        return void 0;
+      }
+      throw this.logger.Error().Err(bytes.Err()).Msg("error get").AsError();
+    }
+    try {
+      return bytes && (0, import_dag_json.parse)(textDecoder2.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");
+    if (filepath.isErr()) {
+      throw this.logger.Error().Err(filepath.Err()).Str("url", this.url.toString()).Msg("error building url").AsError();
+    }
+    let encoded;
+    try {
+      encoded = (0, import_dag_json.format)(state);
+    } catch (e) {
+      throw this.logger.Error().Err(e).Any("state", state).Msg("error format").AsError();
+    }
+    const res = await this.gateway.put(filepath.Ok(), textEncoder2.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);
+    this._onClosed.forEach((fn) => fn());
+    return import_cement6.Result.Ok(void 0);
+  }
+  destroy() {
+    return this.gateway.destroy(this.url);
+  }
+};
+
+// src/blockstore/store-factory.ts
+init_utils();
+function ensureIsIndex(url, isIndex) {
+  if (isIndex) {
+    url.searchParams.set("index", isIndex);
+    return url;
+  } else {
+    url.searchParams.delete("index");
+    return url;
+  }
+}
+function toURL(pathOrUrl, isIndex) {
+  if (pathOrUrl instanceof URL) return ensureIsIndex(pathOrUrl, isIndex);
+  try {
+    const url = new URL(pathOrUrl);
+    return ensureIsIndex(url, isIndex);
+  } catch (e) {
+    const url = new URL(`file://${pathOrUrl}`);
+    return ensureIsIndex(url, isIndex);
+  }
+}
+var storeFactory = /* @__PURE__ */ new Map();
+function buildURL(optURL, loader) {
+  const storeOpts = loader.ebOpts.store;
+  const obuItem = Array.from(storeFactory.values()).find((items) => items.overrideBaseURL);
+  let obuUrl;
+  if (obuItem && obuItem.overrideBaseURL) {
+    obuUrl = new URL(obuItem.overrideBaseURL);
+  }
+  return toURL(optURL || obuUrl || dataDir(loader.name, storeOpts.stores?.base), storeOpts.isIndex);
+}
+function registerStoreProtocol(item) {
+  if (storeFactory.has(item.protocol)) {
+    throw new Error(`protocol ${item.protocol} already registered`);
+  }
+  if (item.overrideBaseURL) {
+    Array.from(storeFactory.values()).forEach((items) => {
+      items.overrideBaseURL = void 0;
+    });
+  }
+  storeFactory.set(item.protocol, item);
+  return () => {
+    storeFactory.delete(item.protocol);
+  };
+}
+function runStoreFactory(url, logger, run) {
+  const item = storeFactory.get(url.protocol);
+  if (!item) {
+    throw logger.Error().Url(url).Str("protocol", url.protocol).Any("keys", Array(storeFactory.keys())).Msg(`unsupported protocol`).AsError();
+  }
+  logger.Debug().Str("protocol", url.protocol).Msg("run");
+  return run(item);
+}
+var onceLoadDataGateway = new import_cement14.KeyedResolvOnce();
+function loadDataGateway(url, logger) {
+  return onceLoadDataGateway.get(url.protocol).once(async () => {
+    return runStoreFactory(url, logger, async (item) => item.data(logger));
+  });
+}
+var onceDataStoreFactory = new import_cement14.KeyedResolvOnce();
+async function dataStoreFactory(loader) {
+  const url = buildURL(loader.ebOpts.store.stores?.data, loader);
+  const logger = ensureLogger(loader.logger, "dataStoreFactory", { url: url.toString() });
+  url.searchParams.set("store", "data");
+  return onceDataStoreFactory.get(url.toString()).once(async () => {
+    const gateway = await loadDataGateway(url, logger);
+    const store = new DataStore(loader.name, url, loader.logger, gateway);
+    await store.start();
+    logger.Debug().Str("prepared", store.url.toString()).Msg("produced");
+    return store;
+  });
+}
+var onceLoadMetaGateway = new import_cement14.KeyedResolvOnce();
+function loadMetaGateway(url, logger) {
+  return onceLoadMetaGateway.get(url.protocol).once(async () => {
+    return runStoreFactory(url, logger, async (item) => item.meta(logger));
+  });
+}
+var onceMetaStoreFactory = new import_cement14.KeyedResolvOnce();
+async function metaStoreFactory(loader) {
+  const url = buildURL(loader.ebOpts.store.stores?.meta, loader);
+  const logger = ensureLogger(loader.logger, "metaStoreFactory", { url: () => url.toString() });
+  url.searchParams.set("store", "meta");
+  return onceMetaStoreFactory.get(url.toString()).once(async () => {
+    logger.Debug().Str("protocol", url.protocol).Msg("pre-protocol switch");
+    const gateway = await loadMetaGateway(url, logger);
+    const store = new MetaStore(loader.name, url, loader.logger, gateway);
+    logger.Debug().Msg("pre-start");
+    await store.start();
+    logger.Debug().Msg("post-start");
+    return store;
+  });
+}
+var onceWalGateway = new import_cement14.KeyedResolvOnce();
+function loadWalGateway(url, logger) {
+  return onceWalGateway.get(url.protocol).once(async () => {
+    return runStoreFactory(url, logger, async (item) => item.wal(logger));
+  });
+}
+var onceRemoteWalFactory = new import_cement14.KeyedResolvOnce();
+async function remoteWalFactory(loader) {
+  const url = buildURL(loader.ebOpts.store.stores?.meta, loader);
+  const logger = ensureLogger(loader.logger, "remoteWalFactory", { url: url.toString() });
+  url.searchParams.set("store", "wal");
+  return onceRemoteWalFactory.get(url.toString()).once(async () => {
+    const gateway = await loadWalGateway(url, logger);
+    logger.Debug().Str("prepared", url.toString()).Msg("produced");
+    const store = new RemoteWAL(loader, url, loader.logger, gateway);
+    await store.start();
+    return store;
+  });
+}
+async function testStoreFactory(url, ilogger) {
+  const logger = ensureLogger(
+    {
+      logger: ilogger
+    },
+    "testStoreFactory"
+  );
+  return runStoreFactory(url, logger, async (item) => item.test(logger));
+}
+function toStoreRuntime(opts, ilogger) {
+  const logger = ensureLogger(ilogger, "toStoreRuntime", {});
+  return {
+    makeMetaStore: (loader) => {
+      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeMetaStore).Msg("makeMetaStore");
+      return (loader.ebOpts.store.makeMetaStore || metaStoreFactory)(loader);
+    },
+    makeDataStore: (loader) => {
+      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeDataStore).Msg("makeDataStore");
+      return (loader.ebOpts.store.makeDataStore || dataStoreFactory)(loader);
+    },
+    makeRemoteWAL: (loader) => {
+      logger.Debug().Str("fromOpts", "" + !!loader.ebOpts.store.makeRemoteWAL).Msg("makeRemoteWAL");
+      return (loader.ebOpts.store.makeRemoteWAL || remoteWalFactory)(loader);
+    },
+    encodeFile: opts.encodeFile || encodeFile,
+    decodeFile: opts.decodeFile || decodeFile
+  };
+}
+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);
+  },
+  test: async (logger) => {
+    const { FileTestStore: FileTestStore2 } = await Promise.resolve().then(() => (init_store_file(), store_file_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);
+  },
+  test: async (logger) => {
+    const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_store_indexdb(), store_indexdb_exports));
+    return new IndexDBTestStore2(logger);
+  }
+});
+registerStoreProtocol({
+  protocol: "sqlite:",
+  data: async (logger) => {
+    const { SQLDataGateway: SQLDataGateway2 } = await Promise.resolve().then(() => (init_store_sql2(), store_sql_exports2));
+    return new SQLDataGateway2(logger);
+  },
+  meta: async (logger) => {
+    const { SQLMetaGateway: SQLMetaGateway2 } = await Promise.resolve().then(() => (init_store_sql2(), store_sql_exports2));
+    return new SQLMetaGateway2(logger);
+  },
+  wal: async (logger) => {
+    const { SQLWalGateway: SQLWalGateway2 } = await Promise.resolve().then(() => (init_store_sql2(), store_sql_exports2));
+    return new SQLWalGateway2(logger);
+  },
+  test: async (logger) => {
+    const { SQLTestStore: SQLTestStore2 } = await Promise.resolve().then(() => (init_store_sql2(), store_sql_exports2));
+    return new SQLTestStore2(logger);
+  }
+});
+
+// src/blockstore/index.ts
+init_gateway();
+
+// src/crdt-helpers.ts
+init_types();
+function time(tag) {
+}
+function timeEnd(tag) {
+}
+function toString(key, logger) {
+  switch (typeof key) {
+    case "string":
+    case "number":
+      return key.toString();
+    default:
+      throw logger.Error().Msg("Invalid key type").AsError();
+  }
+}
+async function applyBulkUpdateToCrdt(store, tblocks, head, updates, logger) {
+  let result = null;
+  if (updates.length > 1) {
+    const batch = await Batch.create(tblocks, head);
+    for (const update of updates) {
+      const link = await writeDocContent(store, tblocks, update, logger);
+      await batch.put(toString(update.id, logger), link);
+    }
+    result = await batch.commit();
+  } else if (updates.length === 1) {
+    const link = await writeDocContent(store, tblocks, updates[0], logger);
+    result = await (0, import_crdt.put)(tblocks, head, toString(updates[0].id, logger), link);
+  }
+  if (!result) throw logger.Error().Uint64("updates.len", updates.length).Msg("Missing result").AsError();
+  if (result.event) {
+    for (const { cid, bytes } of [
+      ...result.additions,
+      // ...result.removals,
+      result.event
+    ]) {
+      tblocks.putSync(cid, bytes);
+    }
+  }
+  return { head: result.head };
+}
+async function writeDocContent(store, blocks, update, logger) {
+  let value;
+  if (update.del) {
+    value = { del: true };
+  } else {
+    if (!update.value) throw logger.Error().Msg("Missing value").AsError();
+    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 });
+  blocks.putSync(block.cid, block.bytes);
+  return block.cid;
+}
+async function processFiles(store, blocks, doc, logger) {
+  if (doc._files) {
+    await processFileset(logger, store, blocks, doc._files);
+  }
+  if (doc._publicFiles) {
+    await processFileset(logger, store, blocks, doc._publicFiles, true);
+  }
+}
+async function processFileset(logger, store, blocks, files, publicFiles = false) {
+  const dbBlockstore = blocks.parent;
+  if (!dbBlockstore.loader) throw logger.Error().Msg("Missing loader, database name is required").AsError();
+  const t = new CarTransaction(dbBlockstore);
+  const didPut = [];
+  for (const filename in files) {
+    if (File === files[filename].constructor) {
+      const file = files[filename];
+      const { cid, blocks: fileBlocks } = await store.encodeFile(file);
+      didPut.push(filename);
+      for (const block of fileBlocks) {
+        t.putSync(block.cid, block.bytes);
+      }
+      files[filename] = { cid, type: file.type, size: file.size };
+    } else {
+      const { cid, type, size, car } = files[filename];
+      if (cid && type && size && car) {
+        files[filename] = { cid, type, size, car };
+      }
+    }
+  }
+  if (didPut.length) {
+    const car = await dbBlockstore.loader.commitFiles(t, { files }, {
+      public: publicFiles
+    });
+    if (car) {
+      for (const name of didPut) {
+        files[name] = { car, ...files[name] };
+      }
+    }
+  }
+}
+async function getValueFromCrdt(blocks, head, key, logger) {
+  if (!head.length) throw logger.Debug().Msg("Getting from an empty database").AsError();
+  const link = await (0, import_crdt.get)(blocks, head, key);
+  if (!link) throw logger.Error().Str("key", key).Msg(`Missing key`).AsError();
+  return await getValueFromLink(blocks, link, logger);
+}
+function readFiles(blocks, { doc }) {
+  if (!doc) return;
+  if (doc._files) {
+    readFileset(blocks, doc._files);
+  }
+  if (doc._publicFiles) {
+    readFileset(blocks, doc._publicFiles, true);
+  }
+}
+function readFileset(blocks, files, isPublic = false) {
+  for (const filename in files) {
+    const fileMeta = files[filename];
+    if (fileMeta.cid) {
+      if (isPublic) {
+        fileMeta.url = `https://${fileMeta.cid.toString()}.ipfs.w3s.link/`;
+      }
+      if (fileMeta.car) {
+        fileMeta.file = async () => await blocks.ebOpts.storeRuntime.decodeFile(
+          {
+            get: async (cid) => {
+              return await blocks.getFile(throwFalsy(fileMeta.car), cid, isPublic);
+            }
+          },
+          fileMeta.cid,
+          fileMeta
+        );
+      }
+    }
+    files[filename] = fileMeta;
+  }
+}
+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 cvalue = {
+    ...value,
+    cid: link
+  };
+  readFiles(blocks, cvalue);
+  return cvalue;
+}
+var DirtyEventFetcher = class extends import_clock2.EventFetcher {
+  async get(link) {
+    try {
+      return super.get(link);
+    } catch (e) {
+      console.error("missing event", link.toString(), e);
+      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 keys = /* @__PURE__ */ new Set();
+  const updates = await gatherUpdates(
+    blocks,
+    eventsFetcher,
+    head,
+    since,
+    [],
+    keys,
+    /* @__PURE__ */ new Set(),
+    opts.limit || Infinity,
+    logger
+  );
+  return { result: updates.reverse(), head };
+}
+async function gatherUpdates(blocks, eventsFetcher, head, since, updates = [], keys, didLinks, limit, logger) {
+  if (limit <= 0) return updates;
+  const sHead = head.map((l) => l.toString());
+  for (const link of since) {
+    if (sHead.includes(link.toString())) {
+      return updates;
+    }
+  }
+  for (const link of head) {
+    if (didLinks.has(link.toString())) continue;
+    didLinks.add(link.toString());
+    const { value: event } = await eventsFetcher.get(link);
+    if (!event) continue;
+    const { type } = event.data;
+    let ops = [];
+    if (type === "batch") {
+      ops = event.data.ops;
+    } else if (type === "put") {
+      ops = [event.data];
+    }
+    for (let i = ops.length - 1; i >= 0; i--) {
+      const { key, value } = ops[i];
+      if (!keys.has(key)) {
+        const docValue = await getValueFromLink(blocks, value, logger);
+        updates.push({ id: key, value: docValue.doc, del: docValue.del, clock: link });
+        limit--;
+        keys.add(key);
+      }
+    }
+    if (event.parents) {
+      updates = await gatherUpdates(blocks, eventsFetcher, event.parents, since, updates, keys, didLinks, limit, logger);
+    }
+  }
+  return updates;
+}
+async function* getAllEntries(blocks, head, logger) {
+  for await (const [key, link] of (0, import_crdt.entries)(blocks, head)) {
+    const docValue = await getValueFromLink(blocks, link, logger);
+    yield { id: key, value: docValue.doc, del: docValue.del };
+  }
+}
+async function* clockVis(blocks, head) {
+  for await (const line of (0, import_clock2.vis)(blocks, head)) {
+    yield line;
+  }
+}
+var isCompacting = false;
+async function doCompact(blockLog, head, logger) {
+  if (isCompacting) {
+    return;
+  }
+  isCompacting = true;
+  time("compact head");
+  for (const cid of head) {
+    const bl = await blockLog.get(cid);
+    if (!bl) throw logger.Error().Ref("cid", cid).Msg("Missing head block").AsError();
+  }
+  timeEnd("compact head");
+  time("compact all entries");
+  for await (const _entry of getAllEntries(blockLog, head, logger)) {
+    continue;
+  }
+  timeEnd("compact all entries");
+  time("compact clock vis");
+  for await (const _line of (0, import_clock2.vis)(blockLog, head)) {
+  }
+  timeEnd("compact clock vis");
+  time("compact root");
+  const result = await (0, import_crdt.root)(blockLog, head);
+  timeEnd("compact root");
+  time("compact root blocks");
+  for (const { cid, bytes } of [...result.additions, ...result.removals]) {
+    blockLog.loggedBlocks.putSync(cid, bytes);
+  }
+  timeEnd("compact root blocks");
+  time("compact changes");
+  await clockChangesSince(blockLog, head, [], {}, logger);
+  timeEnd("compact changes");
+  isCompacting = false;
+}
+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 });
+}
+
+// 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_charwise = __toESM(require("charwise"), 1);
+var DbIndex = __toESM(require("prolly-trees/db-index"), 1);
+var import_utils20 = require("prolly-trees/utils");
+var import_cache2 = 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_utils20.simpleCompare)(aRef, bRef);
+}
+function compare(a, b) {
+  const [aKey, aRef] = a;
+  const [bKey, bRef] = b;
+  const comp = (0, import_utils20.simpleCompare)(aKey, bKey);
+  if (comp !== 0) return comp;
+  return refCompare(aRef, bRef);
+}
+var byKeyOpts = { cache: import_cache2.nocache, chunker: (0, import_utils20.bf)(30), codec: codec3, hasher: import_sha24.sha256, compare };
+var byIdOpts = { cache: import_cache2.nocache, chunker: (0, import_utils20.bf)(30), codec: codec3, hasher: import_sha24.sha256, compare: import_utils20.simpleCompare };
+function indexEntriesForChanges(changes, mapFn) {
+  const indexEntries = [];
+  changes.forEach(({ id: key, value, del }) => {
+    if (del || !value) return;
+    let mapCalled = false;
+    const mapReturn = mapFn({ ...value, _id: key }, (k, v) => {
+      mapCalled = true;
+      if (typeof k === "undefined") return;
+      indexEntries.push({
+        key: [import_charwise.default.encode(k), key],
+        value: v || null
+      });
+    });
+    if (!mapCalled && mapReturn) {
+      indexEntries.push({
+        key: [import_charwise.default.encode(mapReturn), key],
+        value: null
+      });
+    }
+  });
+  return indexEntries;
+}
+function makeProllyGetBlock(blocks) {
+  return async (address) => {
+    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 });
+  };
+}
+async function bulkIndex(tblocks, inIndex, indexEntries, opts) {
+  if (!indexEntries.length) return inIndex;
+  if (!inIndex.root) {
+    if (!inIndex.cid) {
+      let returnRootBlock = void 0;
+      let returnNode = void 0;
+      for await (const node of await DbIndex.create({
+        get: makeProllyGetBlock(tblocks),
+        list: indexEntries,
+        ...opts
+      })) {
+        const block = await node.block;
+        await tblocks.put(block.cid, block.bytes);
+        returnRootBlock = block;
+        returnNode = node;
+      }
+      if (!returnNode || !returnRootBlock) throw new Error("failed to create index");
+      return { root: returnNode, cid: returnRootBlock.cid };
+    } else {
+      inIndex.root = await DbIndex.load({ cid: inIndex.cid, get: makeProllyGetBlock(tblocks), ...opts });
+    }
+  }
+  const { root: root3, blocks: newBlocks } = await inIndex.root.bulk(indexEntries);
+  if (root3) {
+    for await (const block of newBlocks) {
+      await tblocks.put(block.cid, block.bytes);
+    }
+    return { root: root3, cid: (await root3.block).cid };
+  } else {
+    return { root: void 0, cid: void 0 };
+  }
+}
+async function loadIndex(tblocks, cid, opts) {
+  return await DbIndex.load({ cid, get: makeProllyGetBlock(tblocks), ...opts });
+}
+async function applyQuery(crdt, resp, query) {
+  if (query.descending) {
+    resp.result = resp.result.reverse();
+  }
+  if (query.limit) {
+    resp.result = resp.result.slice(0, query.limit);
+  }
+  if (query.includeDocs) {
+    resp.result = await Promise.all(
+      resp.result.map(async (row) => {
+        const val = await crdt.get(row.id);
+        const doc = val ? { ...val.doc, _id: row.id } : void 0;
+        return { ...row, doc };
+      })
+    );
+  }
+  return {
+    rows: resp.result.map(({ key, ...row }) => {
+      return {
+        key: import_charwise.default.decode(key),
+        ...row
+      };
+    })
+  };
+}
+function encodeRange(range) {
+  return [import_charwise.default.encode(range[0]), import_charwise.default.encode(range[1])];
+}
+function encodeKey(key) {
+  return import_charwise.default.encode(key);
+}
+
+// src/indexer.ts
+init_utils();
+function index({ _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);
+    _crdt.indexers.set(name, idx);
+  }
+  return _crdt.indexers.get(name);
+}
+var Index = class {
+  constructor(crdt, name, mapFn, meta) {
+    this.mapFnString = "";
+    this.byKey = new IndexTree();
+    this.byId = new IndexTree();
+    this.includeDocsDefault = false;
+    this.logger = ensureLogger(crdt.logger, "Index");
+    this.blockstore = crdt.indexBlockstore;
+    this.crdt = crdt;
+    this.applyMapFn(name, mapFn, meta);
+    this.name = name;
+    if (!(this.mapFnString || this.initError)) throw this.logger.Error().Msg("missing mapFnString").AsError();
+  }
+  ready() {
+    return Promise.all([this.blockstore.ready(), this.crdt.ready()]).then(() => {
+    });
+  }
+  close() {
+    return Promise.all([this.blockstore.close(), this.crdt.close()]).then(() => {
+    });
+  }
+  destroy() {
+    return Promise.all([this.blockstore.destroy(), this.crdt.destroy()]).then(() => {
+    });
+  }
+  applyMapFn(name, mapFn, meta) {
+    if (mapFn && meta) throw this.logger.Error().Msg("cannot provide both mapFn and meta").AsError();
+    if (this.name && this.name !== name) throw this.logger.Error().Msg("cannot change name").AsError();
+    this.name = name;
+    try {
+      if (meta) {
+        if (this.indexHead && this.indexHead.map((c) => c.toString()).join() !== meta.head.map((c) => c.toString()).join()) {
+          throw this.logger.Error().Msg("cannot apply different head meta").AsError();
+        }
+        if (this.mapFnString) {
+          if (this.mapFnString !== meta.map) {
+            this.logger.Warn().Msg(`cannot apply different mapFn meta: old mapFnString ${this.mapFnString} new mapFnString ${meta.map}`);
+          } else {
+            this.byId.cid = meta.byId;
+            this.byKey.cid = meta.byKey;
+            this.indexHead = meta.head;
+          }
+        } else {
+          this.mapFnString = meta.map;
+          this.byId.cid = meta.byId;
+          this.byKey.cid = meta.byKey;
+          this.indexHead = meta.head;
+        }
+      } else {
+        if (this.mapFn) {
+          if (mapFn) {
+            if (this.mapFn.toString() !== mapFn.toString()) {
+              throw this.logger.Error().Msg("cannot apply different mapFn app2").AsError();
+            }
+          }
+        } else {
+          if (!mapFn) {
+            mapFn = (doc) => doc[name] ?? void 0;
+          }
+          if (this.mapFnString) {
+            if (this.mapFnString !== mapFn.toString()) {
+              throw this.logger.Error().Msg("cannot apply different mapFn app").AsError();
+            }
+          } else {
+            this.mapFnString = mapFn.toString();
+          }
+          this.mapFn = mapFn;
+        }
+      }
+      const matches = /=>\s*(.*)/.test(this.mapFnString);
+      this.includeDocsDefault = matches;
+    } catch (e) {
+      this.initError = e;
+    }
+  }
+  async query(opts = {}) {
+    await this.ready();
+    await this._updateIndex();
+    await this._hydrateIndex();
+    if (!this.byKey.root) {
+      return await applyQuery(this.crdt, { result: [] }, opts);
+    }
+    if (this.includeDocsDefault && opts.includeDocs === void 0) opts.includeDocs = true;
+    if (opts.range) {
+      const eRange = encodeRange(opts.range);
+      return await applyQuery(this.crdt, await throwFalsy(this.byKey.root).range(eRange[0], eRange[1]), opts);
+    }
+    if (opts.key) {
+      const encodedKey = encodeKey(opts.key);
+      return await applyQuery(this.crdt, await throwFalsy(this.byKey.root).get(encodedKey), opts);
+    }
+    if (Array.isArray(opts.keys)) {
+      const results = await Promise.all(
+        opts.keys.map(async (key) => {
+          const encodedKey = encodeKey(key);
+          return (await applyQuery(this.crdt, await throwFalsy(this.byKey.root).get(encodedKey), opts)).rows;
+        })
+      );
+      return { rows: results.flat() };
+    }
+    if (opts.prefix) {
+      if (!Array.isArray(opts.prefix)) opts.prefix = [opts.prefix];
+      const start = [...opts.prefix, NaN];
+      const end = [...opts.prefix, Infinity];
+      const encodedR = encodeRange([start, end]);
+      return await applyQuery(this.crdt, await this.byKey.root.range(...encodedR), opts);
+    }
+    const all = await this.byKey.root.getAllEntries();
+    return await applyQuery(
+      this.crdt,
+      {
+        // @ts-expect-error getAllEntries returns a different type than range
+        result: all.result.map(({ key: [k, id], value }) => ({
+          key: k,
+          id,
+          value
+        }))
+      },
+      opts
+    );
+  }
+  _resetIndex() {
+    this.byId = new IndexTree();
+    this.byKey = new IndexTree();
+    this.indexHead = void 0;
+  }
+  async _hydrateIndex() {
+    if (this.byId.root && this.byKey.root) return;
+    if (!this.byId.cid || !this.byKey.cid) return;
+    this.byId.root = await loadIndex(this.blockstore, this.byId.cid, byIdOpts);
+    this.byKey.root = await loadIndex(this.blockstore, this.byKey.cid, byKeyOpts);
+  }
+  async _updateIndex() {
+    await this.ready();
+    if (this.initError) throw this.initError;
+    if (!this.mapFn) throw this.logger.Error().Msg("No map function defined").AsError();
+    let result, head;
+    if (!this.indexHead || this.indexHead.length === 0) {
+      ({ result, head } = await this.crdt.allDocs());
+    } else {
+      ({ result, head } = await this.crdt.changes(this.indexHead));
+    }
+    if (result.length === 0) {
+      this.indexHead = head;
+    }
+    let staleKeyIndexEntries = [];
+    let removeIdIndexEntries = [];
+    if (this.byId.root) {
+      const removeIds = result.map(({ id: key }) => key);
+      const { result: oldChangeEntries } = await this.byId.root.getMany(removeIds);
+      staleKeyIndexEntries = oldChangeEntries.map((key) => ({ key, del: true }));
+      removeIdIndexEntries = oldChangeEntries.map((key) => ({ key: key[1], del: true }));
+    }
+    const indexEntries = indexEntriesForChanges(result, this.mapFn);
+    const byIdIndexEntries = indexEntries.map(({ key }) => ({
+      key: key[1],
+      value: key
+    }));
+    const indexerMeta = { indexes: /* @__PURE__ */ new Map() };
+    for (const [name, indexer] of this.crdt.indexers) {
+      if (indexer.indexHead) {
+        indexerMeta.indexes?.set(name, {
+          byId: indexer.byId.cid,
+          byKey: indexer.byKey.cid,
+          head: indexer.indexHead,
+          map: indexer.mapFnString,
+          name: indexer.name
+        });
+      }
+    }
+    if (result.length === 0) {
+      return indexerMeta;
+    }
+    const { meta } = await this.blockstore.transaction(async (tblocks) => {
+      this.byId = await bulkIndex(tblocks, this.byId, removeIdIndexEntries.concat(byIdIndexEntries), byIdOpts);
+      this.byKey = await bulkIndex(tblocks, this.byKey, staleKeyIndexEntries.concat(indexEntries), byKeyOpts);
+      this.indexHead = head;
+      if (this.byId.cid && this.byKey.cid) {
+        const idxMeta = {
+          byId: this.byId.cid,
+          byKey: this.byKey.cid,
+          head,
+          map: this.mapFnString,
+          name: this.name
+        };
+        indexerMeta.indexes?.set(this.name, idxMeta);
+      }
+      return indexerMeta;
+    });
+    return meta;
+  }
+};
+
+// src/crdt-clock.ts
+var import_clock3 = require("@web3-storage/pail/clock");
+var import_crdt2 = require("@web3-storage/pail/crdt");
+var import_cement15 = require("@adviser/cement");
+init_types();
+
+// src/apply-head-queue.ts
+function applyHeadQueue(worker, logger) {
+  const queue = [];
+  let isProcessing = false;
+  async function* process() {
+    if (isProcessing || queue.length === 0) return;
+    isProcessing = true;
+    const allUpdates = [];
+    try {
+      while (queue.length > 0) {
+        queue.sort((a, b) => b.updates ? 1 : -1);
+        const task = queue.shift();
+        if (!task) continue;
+        await worker(task.newHead, task.prevHead, task.updates !== null).catch((e) => {
+          throw logger.Error().Err(e).Msg("int_applyHead worker error").AsError();
+        });
+        if (task.updates) {
+          allUpdates.push(...task.updates);
+        }
+        if (!queue.some((t) => t.updates) || task.updates) {
+          const allTasksHaveUpdates = queue.every((task2) => task2.updates !== null);
+          yield { updates: allUpdates, all: allTasksHaveUpdates };
+          allUpdates.length = 0;
+        }
+      }
+    } finally {
+      isProcessing = false;
+      const generator = process();
+      let result = await generator.next();
+      while (!result.done) {
+        result = await generator.next();
+      }
+    }
+  }
+  return {
+    push(task) {
+      queue.push(task);
+      return process();
+    },
+    size() {
+      return queue.length;
+    }
+  };
+}
+
+// src/crdt-clock.ts
+init_utils();
+var CRDTClock = class {
+  constructor(blockstore) {
+    // todo: track local and remote clocks independently, merge on read
+    // that way we can drop the whole remote if we need to
+    // should go with making sure the local clock only references locally available blockstore on write
+    this.head = [];
+    this.zoomers = /* @__PURE__ */ new Set();
+    this.watchers = /* @__PURE__ */ new Set();
+    this.emptyWatchers = /* @__PURE__ */ new Set();
+    this._ready = new import_cement15.ResolveOnce();
+    this.blockstore = blockstore;
+    this.logger = ensureLogger(blockstore.logger, "CRDTClock");
+    this.applyHeadQueue = applyHeadQueue(this.int_applyHead.bind(this), this.logger);
+  }
+  async ready() {
+    return this._ready.once(async () => {
+      await this.blockstore.ready();
+    });
+  }
+  async close() {
+    await this.blockstore.close();
+  }
+  setHead(head) {
+    this.head = head;
+  }
+  async applyHead(newHead, prevHead, updates) {
+    for await (const { updates: updatesAcc, all } of this.applyHeadQueue.push({
+      newHead,
+      prevHead,
+      updates
+    })) {
+      return this.processUpdates(updatesAcc, all, prevHead);
+    }
+  }
+  async processUpdates(updatesAcc, all, prevHead) {
+    let internalUpdates = updatesAcc;
+    if (this.watchers.size && !all) {
+      const changes = await clockChangesSince(throwFalsy(this.blockstore), this.head, prevHead, {}, this.logger);
+      internalUpdates = changes.result;
+    }
+    this.zoomers.forEach((fn) => fn());
+    this.notifyWatchers(internalUpdates || []);
+  }
+  notifyWatchers(updates) {
+    this.emptyWatchers.forEach((fn) => fn());
+    this.watchers.forEach((fn) => fn(updates || []));
+  }
+  onTick(fn) {
+    this.watchers.add(fn);
+  }
+  onTock(fn) {
+    this.emptyWatchers.add(fn);
+  }
+  onZoom(fn) {
+    this.zoomers.add(fn);
+  }
+  async int_applyHead(newHead, prevHead, localUpdates) {
+    const ogHead = sortClockHead(this.head);
+    newHead = sortClockHead(newHead);
+    if (compareClockHeads(ogHead, newHead)) {
+      return;
+    }
+    const ogPrev = sortClockHead(prevHead);
+    if (compareClockHeads(ogHead, ogPrev)) {
+      this.setHead(newHead);
+      return;
+    }
+    const noLoader = !localUpdates;
+    if (!this.blockstore) {
+      throw this.logger.Error().Msg("missing blockstore").AsError();
+    }
+    await validateBlocks(this.logger, newHead, this.blockstore);
+    const { meta } = await this.blockstore.transaction(
+      async (tblocks) => {
+        const advancedHead = await advanceBlocks(this.logger, newHead, tblocks, this.head);
+        const result = await (0, import_crdt2.root)(tblocks, advancedHead);
+        for (const { cid, bytes } of [
+          ...result.additions
+          // ...result.removals
+        ]) {
+          tblocks.putSync(cid, bytes);
+        }
+        return { head: advancedHead };
+      },
+      { noLoader }
+    );
+    this.setHead(meta.head);
+  }
+};
+function sortClockHead(clockHead) {
+  return clockHead.sort((a, b) => a.toString().localeCompare(b.toString()));
+}
+async function validateBlocks(logger, newHead, blockstore) {
+  if (!blockstore) throw logger.Error().Msg("missing blockstore");
+  newHead.map(async (cid) => {
+    const got = await blockstore.get(cid);
+    if (!got) {
+      throw logger.Error().Str("cid", cid.toString()).Msg("int_applyHead missing block").AsError();
+    }
+  });
+}
+function compareClockHeads(head1, head2) {
+  return head1.toString() === head2.toString();
+}
+async function advanceBlocks(logger, newHead, tblocks, head) {
+  for (const cid of newHead) {
+    try {
+      head = await (0, import_clock3.advance)(tblocks, head, cid);
+    } catch (e) {
+      logger.Debug().Err(e).Msg("failed to advance head");
+      continue;
+    }
+  }
+  return head;
+}
+
+// src/crdt.ts
+init_utils();
+var CRDT = class {
+  constructor(name, opts = {}) {
+    this.onceReady = new import_cement16.ResolveOnce();
+    this.indexers = /* @__PURE__ */ new Map();
+    this.name = name;
+    this.logger = ensureLogger(opts, "CRDT");
+    this.opts = opts;
+    this.blockstore = blockstoreFactory({
+      name,
+      applyMeta: async (meta) => {
+        const crdtMeta = meta;
+        if (!crdtMeta.head) throw this.logger.Error().Msg("missing head").AsError();
+        await this.clock.applyHead(crdtMeta.head, []);
+      },
+      compact: async (blocks) => {
+        await doCompact(blocks, this.clock.head, this.logger);
+        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({
+      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);
+        }
+      },
+      crypto: this.opts.crypto,
+      store: { ...this.opts.store, isIndex: this.opts.store?.isIndex || "idx" },
+      public: this.opts.public
+    });
+    this.clock = new CRDTClock(this.blockstore);
+    this.clock.onZoom(() => {
+      for (const idx of this.indexers.values()) {
+        idx._resetIndex();
+      }
+    });
+  }
+  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];
+    const done = await this.blockstore.transaction(async (blocks) => {
+      const { head } = await applyBulkUpdateToCrdt(
+        this.blockstore.ebOpts.storeRuntime,
+        blocks,
+        this.clock.head,
+        updates,
+        this.logger
+      );
+      updates = updates.map((dupdate) => {
+        readFiles(this.blockstore, { doc: dupdate.value });
+        return dupdate;
+      });
+      return { head };
+    });
+    await this.clock.applyHead(done.meta.head, prevHead, updates);
+    return done.meta;
+  }
+  // if (snap) await this.clock.applyHead(crdtMeta.head, this.clock.head)
+  async allDocs() {
+    await this.ready();
+    const result = [];
+    for await (const entry of getAllEntries(this.blockstore, this.clock.head, this.logger)) {
+      result.push(entry);
+    }
+    return { result, head: this.clock.head };
+  }
+  async vis() {
+    await this.ready();
+    const txt = [];
+    for await (const line of clockVis(this.blockstore, this.clock.head)) {
+      txt.push(line);
+    }
+    return txt.join("\n");
+  }
+  async getBlock(cidString) {
+    await this.ready();
+    return await getBlock(this.blockstore, cidString);
+  }
+  async get(key) {
+    await this.ready();
+    const result = await getValueFromCrdt(this.blockstore, this.clock.head, key, this.logger);
+    if (result.del) return void 0;
+    return result;
+  }
+  async changes(since = [], opts = {}) {
+    await this.ready();
+    return await clockChangesSince(this.blockstore, this.clock.head, since, opts, this.logger);
+  }
+  async compact() {
+    const blocks = this.blockstore;
+    return await blocks.compact();
+  }
+};
+
+// 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_cement17.ResolveOnce();
+    this.name = name;
+    this.opts = opts || this.opts;
+    this.logger = ensureLogger(this.opts, "Database");
+    this._crdt = new CRDT(name, this.opts);
+    this.blockstore = this._crdt.blockstore;
+    this._writeQueue = writeQueue(async (updates) => {
+      return await this._crdt.bulk(updates);
+    });
+    this._crdt.clock.onTock(() => {
+      this._no_update_notify();
+    });
+  }
+  static {
+    this.databases = /* @__PURE__ */ new Map();
+  }
+  async close() {
+    await this.ready();
+    await this._crdt.close();
+    await this.blockstore.close();
+  }
+  async destroy() {
+    await this.ready();
+    await this._crdt.destroy();
+    await this.blockstore.destroy();
+  }
+  async ready() {
+    return this._ready.once(async () => {
+      await SysContainer.start();
+      await this._crdt.ready();
+      await this.blockstore.ready();
+    });
+  }
+  async get(id) {
+    this.logger.Debug().Str("id", id).Msg("get-pre-ready");
+    await this.ready();
+    this.logger.Debug().Str("id", id).Msg("get-post-ready");
+    const got = await this._crdt.get(id).catch((e) => {
+      throw new NotFoundError(`Not found: ${id} - ${e.message}`);
+    });
+    if (!got) throw new NotFoundError(`Not found: ${id}`);
+    const { doc } = got;
+    return { ...doc, _id: id };
+  }
+  async put(doc) {
+    this.logger.Debug().Str("id", doc._id).Msg("put-pre-ready");
+    await this.ready();
+    this.logger.Debug().Str("id", doc._id).Msg("put-post-ready");
+    const { _id, ...value } = doc;
+    const docId = _id || (0, import_uuidv73.uuidv7)();
+    const result = await this._writeQueue.push({
+      id: docId,
+      value: {
+        ...value,
+        _id: docId
+      }
+    });
+    return { id: docId, clock: result?.head };
+  }
+  async del(id) {
+    await this.ready();
+    const result = await this._writeQueue.push({ id, del: true });
+    return { id, clock: result?.head };
+  }
+  async changes(since = [], opts = {}) {
+    await this.ready();
+    const { result, head } = await this._crdt.changes(since, opts);
+    const rows = result.map(({ id: key, value, del, clock }) => ({
+      key,
+      value: del ? { _id: key, _deleted: true } : { _id: key, ...value },
+      clock
+    }));
+    return { rows, clock: head };
+  }
+  async allDocs() {
+    await this.ready();
+    const { result, head } = await this._crdt.allDocs();
+    const rows = result.map(({ id: key, value, del }) => ({
+      key,
+      value: del ? { _id: key, _deleted: true } : { _id: key, ...value }
+    }));
+    return { rows, clock: head };
+  }
+  async allDocuments() {
+    return this.allDocs();
+  }
+  subscribe(listener, updates) {
+    if (updates) {
+      if (!this._listening) {
+        this._listening = true;
+        this._crdt.clock.onTick((updates2) => {
+          void this._notify(updates2);
+        });
+      }
+      this._listeners.add(listener);
+      return () => {
+        this._listeners.delete(listener);
+      };
+    } else {
+      this._noupdate_listeners.add(listener);
+      return () => {
+        this._noupdate_listeners.delete(listener);
+      };
+    }
+  }
+  // todo if we add this onto dbs in fireproof.ts then we can make index.ts a separate package
+  async query(field, opts = {}) {
+    await this.ready();
+    const _crdt = this._crdt;
+    const idx = typeof field === "string" ? index({ _crdt }, field) : index({ _crdt }, makeName(field.toString()), field);
+    return await idx.query(opts);
+  }
+  async compact() {
+    await this.ready();
+    await this._crdt.compact();
+  }
+  async _notify(updates) {
+    await this.ready();
+    if (this._listeners.size) {
+      const docs = updates.map(({ id, value }) => ({ ...value, _id: id }));
+      for (const listener of this._listeners) {
+        await (async () => await listener(docs))().catch((e) => {
+          this.logger.Error().Err(e).Msg("subscriber error");
+        });
+      }
+    }
+  }
+  async _no_update_notify() {
+    await this.ready();
+    if (this._noupdate_listeners.size) {
+      for (const listener of this._noupdate_listeners) {
+        await (async () => await listener([]))().catch((e) => {
+          this.logger.Error().Err(e).Msg("subscriber error");
+        });
+      }
+    }
+  }
+};
+function toSortedArray(set) {
+  if (!set) return [];
+  return Object.entries(set).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => ({ [k]: v }));
+}
+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
+    })
+  );
+  let db = Database.databases.get(key);
+  if (!db) {
+    db = new Database(name, opts);
+    Database.databases.set(key, db);
+  }
+  return db;
+}
+function makeName(fnString) {
+  const regex = /\(([^,()]+,\s*[^,()]+|\[[^\]]+\],\s*[^,()]+)\)/g;
+  let found = null;
+  const matches = Array.from(fnString.matchAll(regex), (match) => match[1].trim());
+  if (matches.length === 0) {
+    found = /=>\s*(.*)/.exec(fnString);
+  }
+  if (!found) {
+    return fnString;
+  } else {
+    return found[1];
+  }
+}
+
+// src/index.ts
+init_types();
+init_runtime();
+init_runtime();
+init_utils();
+
+// src/version.ts
+var PACKAGE_VERSION = Object.keys({
+  "0.0.0-dev": "xxxx"
+})[0];
+//# sourceMappingURL=index.cjs.map