@fireproof/core 0.19.8-dev-alldocs-export → 0.19.8-dev-getid

package/index.cjs

@@ -58,17 +58,13 @@ __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),
+    // ...(await import("node:os")),
+    // ...(await import("node:url")),
+    ...os,
+    ...url,
     ...fs,
     join,
     stat: fs.stat,
@@ -77,22 +73,46 @@ async function createNodeSysContainer() {
     writefile: fs.writeFile
   };
 }
+var fs, path, os, url;
 var init_node_sys_container = __esm({
   "src/runtime/node-sys-container.ts"() {
     "use strict";
     init_sys_container();
+    fs = __toESM(require("fs/promises"), 1);
+    path = __toESM(require("path"), 1);
+    os = __toESM(require("os"), 1);
+    url = __toESM(require("url"), 1);
   }
 });
 
 // src/runtime/sys-container.ts
+function isSet(value, ref = globalThis) {
+  const [head, ...tail] = value.split(".");
+  if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
+    if (tail.length <= 1) {
+      return true;
+    }
+    return isSet(tail.join("."), ref[head]);
+  }
+  return false;
+}
+function runtimeFn() {
+  const isNodeIsh = isSet("process.versions.node");
+  const isDeno = isSet("Deno");
+  return {
+    isNodeIsh,
+    isBrowser: !(isNodeIsh || isDeno),
+    isDeno,
+    isReactNative: false
+  };
+}
 function join(...paths) {
   return paths.map((i) => i.replace(/\/+$/, "")).join("/");
 }
-var stdEnv, import_uuidv7, import_cement, onceStart, envImpl, sysContainer, SysContainer;
+var 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();
@@ -109,18 +129,18 @@ var init_sys_container = __esm({
         this.freight = {
           state: "seeded",
           join,
-          dirname: (path) => path.split("/").slice(0, -1).join("/"),
+          dirname: (path2) => path2.split("/").slice(0, -1).join("/"),
           homedir: () => {
             throw new Error("SysContainer:homedir is not available in seeded state");
           },
           fileURLToPath: (strurl) => {
-            let url;
+            let url2;
             if (typeof strurl === "string") {
-              url = new URL(strurl);
+              url2 = new URL(strurl);
             } else {
-              url = strurl;
+              url2 = strurl;
             }
-            return url.pathname;
+            return url2.pathname;
           },
           // assert: (condition: unknown, message?: string | Error) => {
           //   if (!condition) {
@@ -145,13 +165,14 @@ var init_sys_container = __esm({
           this.logSeeded("homedir");
           return throwFalsy(this.freight).homedir();
         };
+        this.runtime = runtimeFn;
         this.env = envImpl;
       }
       async start() {
         await onceStart.once(async () => {
           switch (this.freight.state) {
             case "seeded":
-              if (stdEnv.isNode) {
+              if (this.runtime().isNodeIsh) {
                 const { createNodeSysContainer: createNodeSysContainer2 } = await Promise.resolve().then(() => (init_node_sys_container(), node_sys_container_exports));
                 this.freight = await createNodeSysContainer2();
               } else {
@@ -164,49 +185,49 @@ var init_sys_container = __esm({
           }
         });
       }
-      async readdir(path, options) {
+      async readdir(path2, options) {
         this.logSeeded("readdir");
-        return throwFalsy(this.freight).readdir(path, options) || [];
+        return throwFalsy(this.freight).readdir(path2, options) || [];
       }
-      async readdirent(path, options) {
+      async readdirent(path2, options) {
         this.logSeeded("readdirent");
-        return throwFalsy(this.freight).readdir(path, { ...options, withFileTypes: true }) || [];
+        return throwFalsy(this.freight).readdir(path2, { ...options, withFileTypes: true }) || [];
       }
-      async readfile(path, options) {
+      async readfile(path2, options) {
         this.logSeeded("readfile");
-        return throwFalsy(this.freight).readfile(path, options);
+        return throwFalsy(this.freight).readfile(path2, options);
       }
-      async mkdir(path, options) {
+      async mkdir(path2, options) {
         this.logSeeded("mkdir");
-        return throwFalsy(this.freight).mkdir(path, options);
+        return throwFalsy(this.freight).mkdir(path2, options);
       }
-      async rm(path, options) {
+      async rm(path2, options) {
         this.logSeeded("rm");
-        return throwFalsy(this.freight).rm(path, options);
+        return throwFalsy(this.freight).rm(path2, options);
       }
-      async unlink(path) {
+      async unlink(path2) {
         this.logSeeded("unlink");
-        return throwFalsy(this.freight).unlink(path);
+        return throwFalsy(this.freight).unlink(path2);
       }
-      async writefile(path, data) {
+      async writefile(path2, data) {
         this.logSeeded("writefile");
-        return throwFalsy(this.freight).writefile(path, data);
+        return throwFalsy(this.freight).writefile(path2, data);
       }
       async copyFile(source, destination) {
         this.logSeeded("copyFile");
         return throwFalsy(this.freight).copyFile(source, destination);
       }
-      async stat(path) {
+      async stat(path2) {
         this.logSeeded("stat");
-        return throwFalsy(this.freight).stat(path);
+        return throwFalsy(this.freight).stat(path2);
       }
-      fileURLToPath(url) {
+      fileURLToPath(url2) {
         this.logSeeded("fileURLToPath");
-        return throwFalsy(this.freight).fileURLToPath(url);
+        return throwFalsy(this.freight).fileURLToPath(url2);
       }
-      dirname(path) {
+      dirname(path2) {
         this.logSeeded("dirname");
-        return throwFalsy(this.freight).dirname(path);
+        return throwFalsy(this.freight).dirname(path2);
       }
       join(...args) {
         this.logSeeded("join");
@@ -226,63 +247,61 @@ var init_sys_container = __esm({
 // src/runtime/data-dir.ts
 function dataDir(name, base) {
   if (!base) {
-    if (import_std_env.isNode || import_std_env.isDeno) {
+    if (SysContainer.runtime().isNodeIsh || SysContainer.runtime().isDeno) {
       base = SysContainer.env.get("FP_STORAGE_URL") || `file://${SysContainer.join(SysContainer.homedir(), ".fireproof")}`;
     } else {
       base = `indexdb://fp`;
     }
   }
-  let url;
+  let url2;
   if (typeof base === "string") {
     try {
-      url = new URL(base.toString());
+      url2 = new URL(base.toString());
     } catch (e) {
       try {
         base = `file://${base}`;
-        url = new URL(base);
+        url2 = new URL(base);
       } catch (e2) {
         throw new Error(`invalid base url: ${base}`);
       }
     }
   } else {
-    url = base;
+    url2 = base;
   }
-  url.searchParams.set("name", name || "");
-  return url.toString();
+  url2.searchParams.set("name", name || "");
+  return url2.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");
+async function getPath(url2, logger) {
+  const basePath = url2.toString().replace(new RegExp(`^${url2.protocol}//`), "").replace(/\?.*$/, "");
+  const name = url2.searchParams.get("name");
   if (name) {
-    const version = url.searchParams.get("version");
-    if (!version) throw logger.Error().Str("url", url.toString()).Msg(`version not found`).AsError();
+    const version = url2.searchParams.get("version");
+    if (!version) throw logger.Error().Str("url", url2.toString()).Msg(`version not found`).AsError();
     return SysContainer.join(basePath, version, name);
   }
   return SysContainer.join(basePath);
 }
-function getFileName(url, key, logger) {
-  switch (getStore(url, logger, (...a) => a.join("/"))) {
+function getFileName(url2, key, logger) {
+  switch (getStore(url2, logger, (...a) => a.join("/"))) {
     case "data":
       return key + ".car";
     case "meta":
       return key + ".json";
     default:
-      throw logger.Error().Str("url", url.toString()).Msg(`unsupported store type`).AsError();
+      throw logger.Error().Str("url", url2.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;
+function ensureIndexName(url2, name) {
+  if (url2.searchParams.has("index")) {
+    name = (url2.searchParams.get("index")?.replace(/[^a-zA-Z0-9]/g, "") || "idx") + "-" + name;
   }
   return name;
 }
@@ -294,95 +313,6 @@ var init_store_file_utils = __esm({
   }
 });
 
-// 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/crypto.ts
 var crypto_exports = {};
 __export(crypto_exports, {
@@ -509,21 +439,11 @@ var init_store_indexdb_version = __esm({
   }
 });
 
-// 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,
   crypto: () => crypto_exports,
   dataDir: () => dataDir,
@@ -531,8 +451,7 @@ __export(runtime_exports, {
   files: () => files_exports,
   getFileName: () => getFileName,
   getPath: () => getPath,
-  join: () => join,
-  sql: () => store_sql_exports
+  join: () => join
 });
 var init_runtime = __esm({
   "src/runtime/index.ts"() {
@@ -540,12 +459,10 @@ var init_runtime = __esm({
     init_sys_container();
     init_data_dir();
     init_store_file_utils();
-    init_store_sql();
     init_crypto();
     init_files();
     init_store_file_version();
     init_store_indexdb_version();
-    init_version();
   }
 });
 
@@ -608,25 +525,25 @@ function ensureLogger(optsOrLogger, componentName, ctx) {
   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);
+function getStore(url2, logger, joiner) {
+  let result = url2.searchParams.get("store");
+  if (!result) throw logger.Error().Str("url", url2.toString()).Msg(`store not found`).AsError();
+  if (url2.searchParams.has("index")) {
+    result = joiner(url2.searchParams.get("index") || "idx", result);
   }
   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();
+function getKey(url2, logger) {
+  const result = url2.searchParams.get("key");
+  if (!result) throw logger.Error().Str("url", url2.toString()).Msg(`key not found`).AsError();
   return result;
 }
-function getName(url, logger) {
-  let result = url.searchParams.get("name");
+function getName(url2, logger) {
+  let result = url2.searchParams.get("name");
   if (!result) {
-    result = SysContainer.dirname(url.pathname);
+    result = SysContainer.dirname(url2.pathname);
     if (result.length === 0) {
-      throw logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
+      throw logger.Error().Str("url", url2.toString()).Msg(`name not found`).AsError();
     }
   }
   return result;
@@ -672,209 +589,6 @@ var init_gateway = __esm({
   }
 });
 
-// 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, {
@@ -883,18 +597,18 @@ __export(store_file_exports, {
   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");
+async function ensureVersionFile(path2, logger) {
+  let once = versionFiles.get(path2);
+  if (!once) {
+    once = new import_cement6.ResolveOnce();
+    versionFiles.set(path2, once);
+  }
+  await once.once(async () => {
+    await SysContainer.mkdir(path2, { recursive: true });
+    const vFile = SysContainer.join(path2, "version");
     const vFileStat = await SysContainer.stat(vFile).catch(() => void 0);
     if (!vFileStat) {
-      await SysContainer.writefile(SysContainer.join(path, "version"), FILESTORE_VERSION);
+      await SysContainer.writefile(SysContainer.join(path2, "version"), FILESTORE_VERSION);
       return;
     } else if (!vFileStat.isFile()) {
       throw logger.Error().Str("file", vFile).Msg(`version file is a directory`).AsError();
@@ -904,7 +618,7 @@ async function ensureVersionFile(path, logger) {
       console.warn(`version mismatch:${vFile}: ${v.toString()}!=${FILESTORE_VERSION}`);
     }
   });
-  return path;
+  return path2;
 }
 function toArrayBuffer(buffer) {
   const ab = new ArrayBuffer(buffer.length);
@@ -914,13 +628,13 @@ function toArrayBuffer(buffer) {
   }
   return view;
 }
-var import_cement7, versionFiles, FileGateway, FileWALGateway, FileMetaGateway, FileDataGateway, FileTestStore;
+var import_cement6, 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");
+    import_cement6 = require("@adviser/cement");
     init_utils();
     init_gateway();
     init_store_file_utils();
@@ -933,54 +647,54 @@ var init_store_file = __esm({
         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());
+          const url2 = await this.buildUrl(baseURL, "dummy");
+          if (url2.isErr()) return url2;
+          const dbdir = this.getFilePath(url2.Ok());
           await SysContainer.mkdir(SysContainer.dirname(dbdir), { recursive: true });
           const dbroot = SysContainer.dirname(dbdir);
-          this.logger.Debug().Str("url", url.Ok().toString()).Str("dbroot", SysContainer.dirname(dbroot)).Msg("start");
+          this.logger.Debug().Str("url", url2.Ok().toString()).Str("dbroot", SysContainer.dirname(dbroot)).Msg("start");
           await ensureVersionFile(dbroot, this.logger);
         });
       }
       async close() {
-        return import_cement7.Result.Ok(void 0);
+        return import_cement6.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;
+      getFilePath(url2) {
+        const path2 = url2.toString().replace(/^file:\/\//, "").replace(/\?.*$/, "");
+        this.logger.Debug().Str("url", url2.toString()).Str("path", path2).Msg("getFilePath");
+        return path2;
       }
-      async put(url, body) {
+      async put(url2, body) {
         return exception2Result(async () => {
-          const file = this.getFilePath(url);
-          this.logger.Debug().Str("url", url.toString()).Str("file", file).Msg("put");
+          const file = this.getFilePath(url2);
+          this.logger.Debug().Str("url", url2.toString()).Str("file", file).Msg("put");
           await SysContainer.writefile(file, body);
         });
       }
-      async get(url) {
+      async get(url2) {
         return exceptionWrapper(async () => {
-          const file = this.getFilePath(url);
+          const file = this.getFilePath(url2);
           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));
+            this.logger.Debug().Url(url2).Str("file", file).Msg("get");
+            return import_cement6.Result.Ok(new Uint8Array(res));
           } catch (e) {
             if (isNotFoundError(e)) {
-              return import_cement7.Result.Err(new NotFoundError(`file not found: ${file}`));
+              return import_cement6.Result.Err(new NotFoundError(`file not found: ${file}`));
             }
-            return import_cement7.Result.Err(e);
+            return import_cement6.Result.Err(e);
           }
         });
       }
-      async delete(url) {
+      async delete(url2) {
         return exception2Result(async () => {
-          await SysContainer.unlink(this.getFilePath(url));
+          await SysContainer.unlink(this.getFilePath(url2));
         });
       }
       async destroyDir(baseURL) {
-        const url = await this.buildUrl(baseURL, "x");
-        if (url.isErr()) return url;
-        const filepath = SysContainer.dirname(this.getFilePath(url.Ok()));
+        const url2 = await this.buildUrl(baseURL, "x");
+        if (url2.isErr()) return url2;
+        const filepath = SysContainer.dirname(this.getFilePath(url2.Ok()));
         let dir = [];
         try {
           dir = await SysContainer.readdir(filepath);
@@ -999,7 +713,7 @@ var init_store_file = __esm({
             }
           }
         }
-        return import_cement7.Result.Ok(void 0);
+        return import_cement6.Result.Ok(void 0);
       }
     };
     FileWALGateway = class extends FileGateway {
@@ -1010,9 +724,9 @@ var init_store_file = __esm({
         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);
+        const url2 = new URL(baseUrl.toString());
+        url2.pathname = SysContainer.join(await getPath(baseUrl, this.logger), ensureIndexName(baseUrl, "wal"), key + ".json");
+        return import_cement6.Result.Ok(url2);
       }
     };
     FileMetaGateway = class extends FileGateway {
@@ -1023,9 +737,9 @@ var init_store_file = __esm({
         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);
+        const url2 = new URL(baseUrl.toString());
+        url2.pathname = SysContainer.join(await getPath(baseUrl, this.logger), ensureIndexName(baseUrl, "meta"), key + ".json");
+        return import_cement6.Result.Ok(url2);
       }
     };
     FileDataGateway = class extends FileGateway {
@@ -1037,21 +751,21 @@ var init_store_file = __esm({
         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);
+        const url2 = new URL(baseUrl.toString());
+        url2.pathname = SysContainer.join(await getPath(baseUrl, this.logger), ensureIndexName(baseUrl, "data"), key + ".car");
+        return import_cement6.Result.Ok(url2);
       }
     };
     FileTestStore = class {
       constructor(logger) {
         this.logger = ensureLogger(logger, "FileTestStore");
       }
-      async get(url, key) {
-        const logger = ensureLogger(this.logger, "get", { url: url.toString(), key });
+      async get(url2, key) {
+        const logger = ensureLogger(this.logger, "get", { url: url2.toString(), key });
         const dbFile = SysContainer.join(
-          await getPath(url, this.logger),
-          getStore(url, this.logger, SysContainer.join),
-          getFileName(url, key, this.logger)
+          await getPath(url2, this.logger),
+          getStore(url2, this.logger, SysContainer.join),
+          getFileName(url2, key, this.logger)
         );
         logger.Debug().Str("dbFile", dbFile).Msg("get");
         const buffer = await SysContainer.readfile(dbFile);
@@ -1062,776 +776,197 @@ var init_store_file = __esm({
   }
 });
 
-// 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-indexdb.ts
+var store_indexdb_exports = {};
+__export(store_indexdb_exports, {
+  IndexDBDataGateway: () => IndexDBDataGateway,
+  IndexDBMetaGateway: () => IndexDBMetaGateway,
+  IndexDBTestStore: () => IndexDBTestStore,
+  IndexDBWalGateway: () => IndexDBWalGateway,
+  getIndexDBName: () => getIndexDBName
 });
-
-// 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();
-  }
+function ensureVersion(url2) {
+  const ret = new URL(url2.toString());
+  ret.searchParams.set("version", url2.searchParams.get("version") || INDEXDB_VERSION);
+  return ret;
 }
-var init_sql_connection_factory = __esm({
-  "src/runtime/store-sql/sql-connection-factory.ts"() {
-    "use strict";
-    init_utils();
-    init_sqlite_adapter_better_sqlite3();
+function sanitzeKey(key) {
+  if (key.length === 1) {
+    key = key[0];
   }
-});
-
-// 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);
+  return key;
 }
-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();
+async function connectIdb(url2, logger) {
+  const dbName = getIndexDBName(url2, logger);
+  const once = 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
+          });
         });
       }
-    };
-  }
-});
-
-// 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;
+    });
+    const found = await db.get("version", "version");
+    const version = url2.searchParams.get("version") || INDEXDB_VERSION;
+    if (!found) {
+      await db.put("version", { version }, "version");
+    } else if (found.version !== version) {
+      logger.Warn().Str("url", url2.toString()).Str("version", version).Str("found", found.version).Msg("version mismatch");
     }
-    default:
-      throw ensureLogger(db.opts, "WalStoreFactory").Error().Msg("unsupported db connection").AsError();
-  }
+    return { db, dbName, version };
+  });
+  url2.searchParams.set("version", once.version);
+  return once.db;
 }
-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();
-  }
+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(".");
 }
-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();
-  }
+function getIndexDBName(iurl, logger) {
+  const url2 = ensureVersion(iurl);
+  const fullDb = url2.pathname.replace(/^\/+/, "").replace(/\?.*$/, "");
+  const dbName = url2.searchParams.get("name");
+  if (!dbName) throw logger.Error().Str("url", url2.toString()).Msg(`name not found`).AsError();
+  const result = joinDBName(fullDb, dbName);
+  const objStore = getStore(url2, logger, joinDBName);
+  const connectionKey = [result, objStore].join(":");
+  return {
+    fullDb: result,
+    objStore,
+    connectionKey,
+    dbName
+  };
 }
-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"() {
+var import_idb, import_cement7, onceIndexDB, IndexDBGateway, IndexDBDataGateway, IndexDBWalGateway, IndexDBMetaGateway, txtEncoder, IndexDBTestStore;
+var init_store_indexdb = __esm({
+  "src/runtime/store-indexdb.ts"() {
     "use strict";
-    import_cement13 = require("@adviser/cement");
-    init_sql_connection_factory();
-    init_store_version_factory();
+    import_idb = require("idb");
+    import_cement7 = require("@adviser/cement");
+    init_store_indexdb_version();
     init_utils();
     init_gateway();
-    SQLWalGateway = class {
+    init_sys_container();
+    onceIndexDB = new import_cement7.KeyedResolvOnce();
+    IndexDBGateway = class {
       constructor(logger) {
-        this.walSQLStore = {};
-        this.logger = ensureLogger(logger, "SQLWalGateway");
+        this.db = {};
+        this.logger = logger;
       }
-      buildUrl(baseUrl, key) {
-        const url = new URL(baseUrl.toString());
-        url.searchParams.set("key", key);
-        return Promise.resolve(import_cement13.Result.Ok(url));
+      idb() {
+        this.db;
       }
-      async start(baseUrl) {
+      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;
+          this.logger.Debug().Url(baseURL).Msg("starting");
+          await SysContainer.start();
+          this.db = await connectIdb(baseURL, this.logger);
+          this.logger.Debug().Url(baseURL).Msg("started");
         });
       }
-      close(baseUrl) {
-        return this.walSQLStore.close(baseUrl);
-      }
-      destroy(baseUrl) {
-        return this.walSQLStore.destroy(baseUrl);
+      async close() {
+        return import_cement7.Result.Ok(void 0);
       }
-      async put(url, body) {
+      async destroy(baseUrl) {
         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
-          });
+          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) {
+      async get(url2) {
         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}`));
+          const key = getKey(url2, this.logger);
+          const store = getStore(url2, this.logger, joinDBName);
+          this.logger.Debug().Url(url2).Str("key", key).Str("store", store).Msg("getting");
+          const tx = this.db.transaction([store], "readonly");
+          const bytes = await tx.objectStore(store).get(sanitzeKey(key));
+          await tx.done;
+          if (!bytes) {
+            return import_cement7.Result.Err(new NotFoundError(`missing ${key}`));
           }
-          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 });
+          return import_cement7.Result.Ok(bytes);
         });
       }
-    };
-    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) {
+      async put(url2, value) {
         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);
+          const key = getKey(url2, this.logger);
+          const store = getStore(url2, this.logger, joinDBName);
+          this.logger.Debug().Url(url2).Str("key", key).Str("store", store).Msg("putting");
+          const tx = this.db.transaction([store], "readwrite");
+          await tx.objectStore(store).put(value, sanitzeKey(key));
+          await tx.done;
         });
       }
-      async delete(url) {
+      async delete(url2) {
         return exception2Result(async () => {
-          const branch = getKey(url, this.logger);
-          const name = getName(url, this.logger);
-          await this.metaSQLStore.delete(url, {
-            name,
-            branch
-          });
+          const key = getKey(url2, this.logger);
+          const store = getStore(url2, this.logger, joinDBName);
+          this.logger.Debug().Url(url2).Str("key", key).Str("store", store).Msg("deleting");
+          const tx = this.db.transaction([store], "readwrite");
+          await tx.objectStore(store).delete(sanitzeKey(key));
+          await tx.done;
+          return import_cement7.Result.Ok(void 0);
         });
       }
     };
-    SQLDataGateway = class {
+    IndexDBDataGateway = class extends IndexDBGateway {
       constructor(logger) {
-        this.dataSQLStore = {};
-        this.logger = ensureLogger(logger, "SQLDataGateway");
+        super(ensureLogger(logger, "IndexDBDataGateway", {}));
       }
       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");
-        });
+        const url2 = new URL(baseUrl.toString());
+        url2.searchParams.set("key", key);
+        return Promise.resolve(import_cement7.Result.Ok(url2));
       }
-      close(baseUrl) {
-        return this.dataSQLStore.close(baseUrl);
-      }
-      destroy(baseUrl) {
-        return this.dataSQLStore.destroy(baseUrl);
+    };
+    IndexDBWalGateway = class extends IndexDBGateway {
+      constructor(logger) {
+        super(ensureLogger(logger, "IndexDBWalGateway", {}));
       }
-      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
-          });
-        });
+      buildUrl(baseUrl, key) {
+        const url2 = new URL(baseUrl.toString());
+        url2.searchParams.set("key", key);
+        return Promise.resolve(import_cement7.Result.Ok(url2));
       }
-      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);
-        });
+    };
+    IndexDBMetaGateway = class extends IndexDBGateway {
+      constructor(logger) {
+        super(ensureLogger(logger, "IndexDBDataGateway", {}));
+        this.branches = /* @__PURE__ */ new Set();
       }
-      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);
-        });
+      async buildUrl(baseUrl, key) {
+        const url2 = new URL(baseUrl.toString());
+        this.branches.add(key);
+        url2.searchParams.set("key", key);
+        return import_cement7.Result.Ok(url2);
       }
     };
-    SQLTestStore = class {
-      constructor(ilogger) {
-        const logger = ensureLogger(ilogger, "SQLTestStore");
-        this.logger = logger;
+    txtEncoder = new TextEncoder();
+    IndexDBTestStore = class {
+      constructor(logger) {
+        this.logger = ensureLogger(logger, "IndexDBTestStore", {});
       }
-      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`);
+      async get(url2, key) {
+        const db = await connectIdb(url2, this.logger);
+        const store = getStore(url2, 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;
       }
     };
   }
@@ -1844,6 +979,7 @@ __export(src_exports, {
   Database: () => Database,
   Index: () => Index,
   PACKAGE_VERSION: () => PACKAGE_VERSION,
+  Result: () => import_cement2.Result,
   blockstore: () => blockstore_exports,
   bs: () => blockstore_exports,
   ensureLogger: () => ensureLogger,
@@ -1864,7 +1000,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/database.ts
 var import_uuidv73 = require("uuidv7");
-var import_cement17 = require("@adviser/cement");
+var import_cement11 = require("@adviser/cement");
 
 // src/write-queue.ts
 function writeQueue(worker, payload = Infinity, unbounded = false) {
@@ -1907,7 +1043,7 @@ function writeQueue(worker, payload = Infinity, unbounded = false) {
 }
 
 // src/crdt.ts
-var import_cement16 = require("@adviser/cement");
+var import_cement10 = require("@adviser/cement");
 
 // src/crdt-helpers.ts
 var import_block6 = require("multiformats/block");
@@ -2115,23 +1251,22 @@ var ConnectREST = class extends ConnectionBase {
 };
 
 // src/blockstore/store-factory.ts
-var import_cement14 = require("@adviser/cement");
+var import_cement8 = require("@adviser/cement");
 init_data_dir();
 init_files();
 
 // 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");
+var import_cement5 = 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");
+var import_cement4 = require("@adviser/cement");
 
 // src/blockstore/types.ts
 function toCIDBlock(block) {
@@ -2187,7 +1322,7 @@ 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_utils6 = require("prolly-trees/utils");
 var import_cache = require("prolly-trees/cache");
 var import_cid_set = require("prolly-trees/cid-set");
 
@@ -2375,7 +1510,7 @@ function makeEncDec(logger, crypto2, randomBytes2) {
   };
   return { encrypt, decrypt };
 }
-var chunker = (0, import_utils8.bf)(30);
+var chunker = (0, import_utils6.bf)(30);
 function hexStringToUint8Array(hexString) {
   const length = hexString.length;
   const uint8Array = new Uint8Array(length / 2);
@@ -2699,7 +1834,7 @@ var Loader = class {
     this.getBlockCache = /* @__PURE__ */ new Map();
     this.seenMeta = /* @__PURE__ */ new Set();
     this.writeLimit = (0, import_p_limit.default)(1);
-    this.onceReady = new import_cement5.ResolveOnce();
+    this.onceReady = new import_cement4.ResolveOnce();
     this.name = name;
     this.ebOpts = defaultedBlockstoreRuntime(
       {
@@ -3093,12 +2228,18 @@ var Loader = class {
 };
 
 // src/blockstore/store.ts
+function guardVersion(url2) {
+  if (!url2.searchParams.has("version")) {
+    return import_cement5.Result.Err(`missing version: ${url2.toString()}`);
+  }
+  return import_cement5.Result.Ok(url2);
+}
 var VersionedStore = class {
-  constructor(name, url, logger) {
+  constructor(name, url2, logger) {
     this._onStarted = [];
     this._onClosed = [];
     this.name = name;
-    this.url = url;
+    this.url = url2;
     this.logger = logger;
   }
   onStarted(fn) {
@@ -3108,11 +2249,11 @@ var VersionedStore = class {
     this._onClosed.push(fn);
   }
 };
-var textEncoder2 = new TextEncoder();
-var textDecoder2 = new TextDecoder();
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
 var MetaStore = class extends VersionedStore {
-  constructor(name, url, logger, gateway) {
-    super(name, url, ensureLogger(logger, "MetaStore", {}));
+  constructor(name, url2, logger, gateway) {
+    super(name, url2, ensureLogger(logger, "MetaStore", {}));
     this.tag = "header-base";
     this.gateway = gateway;
   }
@@ -3136,19 +2277,19 @@ var MetaStore = class extends VersionedStore {
   }
   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 url2 = await this.gateway.buildUrl(this.url, branch || "main");
+    if (url2.isErr()) {
+      throw this.logger.Error().Result("buidUrl", url2).Str("branch", branch || "").Url(this.url).Msg("got error from gateway.buildUrl").AsError();
     }
-    const bytes = await this.gateway.get(url.Ok());
+    const bytes = await this.gateway.get(url2.Ok());
     if (bytes.isErr()) {
       if (isNotFoundError(bytes)) {
         return void 0;
       }
-      throw this.logger.Error().Err(bytes.Err()).Msg("gateway get").AsError();
+      throw this.logger.Error().Url(url2.Ok()).Result("bytes:", bytes).Msg("gateway get").AsError();
     }
     try {
-      return [this.parseHeader(textDecoder2.decode(bytes.Ok()))];
+      return [this.parseHeader(textDecoder.decode(bytes.Ok()))];
     } catch (e) {
       throw this.logger.Error().Err(e).Msg("parseHeader").AsError();
     }
@@ -3156,11 +2297,11 @@ var MetaStore = class extends VersionedStore {
   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 url2 = await this.gateway.buildUrl(this.url, branch);
+    if (url2.isErr()) {
+      throw this.logger.Error().Err(url2.Err()).Str("branch", branch).Url(this.url).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.put(url.Ok(), textEncoder2.encode(bytes));
+    const res = await this.gateway.put(url2.Ok(), textEncoder.encode(bytes));
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
     }
@@ -3169,19 +2310,19 @@ var MetaStore = class extends VersionedStore {
   async close() {
     await this.gateway.close(this.url);
     this._onClosed.forEach((fn) => fn());
-    return import_cement6.Result.Ok(void 0);
+    return import_cement5.Result.Ok(void 0);
   }
   async destroy() {
     return this.gateway.destroy(this.url);
   }
 };
 var DataStore = class extends VersionedStore {
-  constructor(name, url, logger, gateway) {
+  constructor(name, url2, logger, gateway) {
     super(
       name,
-      url,
+      url2,
       ensureLogger(logger, "DataStore", {
-        url: () => url.toString()
+        url: () => url2.toString()
       })
     );
     this.tag = "car-base";
@@ -3191,13 +2332,13 @@ var DataStore = class extends VersionedStore {
     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");
+      this.logger.Error().Result("gw-start", res).Msg("started-gateway");
       return res;
     }
     this._onStarted.forEach((fn) => fn());
     const version = guardVersion(this.url);
     if (version.isErr()) {
-      this.logger.Error().Err(res.Err()).Msg("guardVersion");
+      this.logger.Error().Result("version", version).Msg("guardVersion");
       await this.close();
       return version;
     }
@@ -3206,11 +2347,11 @@ var DataStore = class extends VersionedStore {
   }
   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 url2 = await this.gateway.buildUrl(this.url, cid.toString());
+    if (url2.isErr()) {
+      throw this.logger.Error().Err(url2.Err()).Str("cid", cid.toString()).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.get(url.Ok());
+    const res = await this.gateway.get(url2.Ok());
     if (res.isErr()) {
       throw res.Err();
     }
@@ -3219,37 +2360,37 @@ var DataStore = class extends VersionedStore {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async save(car, opts) {
     this.logger.Debug().Any("cid", car.cid.toString()).Msg("saving");
-    const 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 url2 = await this.gateway.buildUrl(this.url, car.cid.toString());
+    if (url2.isErr()) {
+      throw this.logger.Error().Err(url2.Err()).Ref("cid", car.cid).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.put(url.Ok(), car.bytes);
+    const res = await this.gateway.put(url2.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;
+    const url2 = await this.gateway.buildUrl(this.url, cid.toString());
+    if (url2.isErr()) {
+      return url2;
     }
-    return this.gateway.delete(url.Ok());
+    return this.gateway.delete(url2.Ok());
   }
   async close() {
     await this.gateway.close(this.url);
     this._onClosed.forEach((fn) => fn());
-    return import_cement6.Result.Ok(void 0);
+    return import_cement5.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"));
+  constructor(loader, url2, logger, gateway) {
+    super(loader.name, url2, ensureLogger(logger, "RemoteWAL"));
     this.tag = "rwal-base";
-    this._ready = new import_cement6.ResolveOnce();
+    this._ready = new import_cement5.ResolveOnce();
     this.walState = { operations: [], noLoaderOps: [], fileOperations: [] };
     this.processing = void 0;
     this.processQueue = new CommitQueue();
@@ -3400,7 +2541,7 @@ var RemoteWAL = class extends VersionedStore {
       throw this.logger.Error().Err(bytes.Err()).Msg("error get").AsError();
     }
     try {
-      return bytes && (0, import_dag_json.parse)(textDecoder2.decode(bytes.Ok()));
+      return bytes && (0, import_dag_json.parse)(textDecoder.decode(bytes.Ok()));
     } catch (e) {
       throw this.logger.Error().Err(e).Msg("error parse").AsError();
     }
@@ -3416,7 +2557,7 @@ var RemoteWAL = class extends VersionedStore {
     } catch (e) {
       throw this.logger.Error().Err(e).Any("state", state).Msg("error format").AsError();
     }
-    const res = await this.gateway.put(filepath.Ok(), textEncoder2.encode(encoded));
+    const res = await this.gateway.put(filepath.Ok(), textEncoder.encode(encoded));
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Str("filePath", filepath.Ok().toString()).Msg("error saving").AsError();
     }
@@ -3424,7 +2565,7 @@ var RemoteWAL = class extends VersionedStore {
   async close() {
     await this.gateway.close(this.url);
     this._onClosed.forEach((fn) => fn());
-    return import_cement6.Result.Ok(void 0);
+    return import_cement5.Result.Ok(void 0);
   }
   destroy() {
     return this.gateway.destroy(this.url);
@@ -3433,29 +2574,29 @@ var RemoteWAL = class extends VersionedStore {
 
 // src/blockstore/store-factory.ts
 init_utils();
-function ensureIsIndex(url, isIndex) {
+function ensureIsIndex(url2, isIndex) {
   if (isIndex) {
-    url.searchParams.set("index", isIndex);
-    return url;
+    url2.searchParams.set("index", isIndex);
+    return url2;
   } else {
-    url.searchParams.delete("index");
-    return url;
+    url2.searchParams.delete("index");
+    return url2;
   }
 }
 function toURL(pathOrUrl, isIndex) {
   if (pathOrUrl instanceof URL) return ensureIsIndex(pathOrUrl, isIndex);
   try {
-    const url = new URL(pathOrUrl);
-    return ensureIsIndex(url, isIndex);
+    const url2 = new URL(pathOrUrl);
+    return ensureIsIndex(url2, isIndex);
   } catch (e) {
-    const url = new URL(`file://${pathOrUrl}`);
-    return ensureIsIndex(url, isIndex);
+    const url2 = new URL(`file://${pathOrUrl}`);
+    return ensureIsIndex(url2, isIndex);
   }
 }
 var storeFactory = /* @__PURE__ */ new Map();
-function ensureName(name, url) {
-  if (!url.searchParams.has("name")) {
-    url.searchParams.set("name", name);
+function ensureName(name, url2) {
+  if (!url2.searchParams.has("name")) {
+    url2.searchParams.set("name", name);
   }
 }
 function buildURL(optURL, loader) {
@@ -3468,95 +2609,113 @@ function buildURL(optURL, loader) {
   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`);
+  let protocol = item.protocol;
+  if (!protocol.endsWith(":")) {
+    protocol += ":";
+  }
+  if (storeFactory.has(protocol)) {
+    if (!item.overrideBaseURL && storeFactory.get(protocol) !== item) {
+      const logger = ensureLogger({}, "registerStoreProtocol", { protocol });
+      logger.Warn().Msg(`protocol ${protocol} already registered`);
+      return () => {
+      };
+    }
   }
   if (item.overrideBaseURL) {
     Array.from(storeFactory.values()).forEach((items) => {
       items.overrideBaseURL = void 0;
     });
   }
-  storeFactory.set(item.protocol, item);
+  storeFactory.set(protocol, item);
   return () => {
-    storeFactory.delete(item.protocol);
+    storeFactory.delete(protocol);
   };
 }
-function runStoreFactory(url, logger, run) {
-  const item = storeFactory.get(url.protocol);
+function runStoreFactory(url2, logger, run) {
+  const item = storeFactory.get(url2.protocol);
   if (!item) {
-    throw logger.Error().Url(url).Str("protocol", url.protocol).Any("keys", Array(storeFactory.keys())).Msg(`unsupported protocol`).AsError();
+    throw logger.Error().Url(url2).Str("protocol", url2.protocol).Any("keys", Array(storeFactory.keys())).Msg(`unsupported protocol`).AsError();
   }
-  logger.Debug().Str("protocol", url.protocol).Msg("run");
+  logger.Debug().Str("protocol", url2.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 onceLoadDataGateway = new import_cement8.KeyedResolvOnce();
+function loadDataGateway(url2, logger) {
+  return onceLoadDataGateway.get(url2.protocol).once(async () => {
+    return runStoreFactory(url2, logger, async (item) => item.data(logger));
   });
 }
-var onceDataStoreFactory = new import_cement14.KeyedResolvOnce();
+var onceDataStoreFactory = new import_cement8.KeyedResolvOnce();
 async function dataStoreFactory(loader) {
-  const url = buildURL(loader.ebOpts.store.stores?.data, loader);
-  ensureName(loader.name, url);
-  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();
+  const url2 = buildURL(loader.ebOpts.store.stores?.data, loader);
+  ensureName(loader.name, url2);
+  const logger = ensureLogger(loader.logger, "dataStoreFactory", { url: url2.toString() });
+  url2.searchParams.set("store", "data");
+  return onceDataStoreFactory.get(url2.toString()).once(async () => {
+    const gateway = await loadDataGateway(url2, logger);
+    const store = new DataStore(loader.name, url2, loader.logger, gateway);
+    const ret = await store.start();
+    if (ret.isErr()) {
+      throw logger.Error().Result("start", ret).Msg("start failed").AsError();
+    }
     logger.Debug().Str("prepared", store.url.toString()).Msg("produced");
     return store;
   });
 }
-var onceLoadMetaGateway = new import_cement14.KeyedResolvOnce();
-function loadMetaGateway(url, logger) {
-  return onceLoadMetaGateway.get(url.protocol).once(async () => {
-    return runStoreFactory(url, logger, async (item) => item.meta(logger));
+var onceLoadMetaGateway = new import_cement8.KeyedResolvOnce();
+function loadMetaGateway(url2, logger) {
+  return onceLoadMetaGateway.get(url2.protocol).once(async () => {
+    return runStoreFactory(url2, logger, async (item) => item.meta(logger));
   });
 }
-var onceMetaStoreFactory = new import_cement14.KeyedResolvOnce();
+var onceMetaStoreFactory = new import_cement8.KeyedResolvOnce();
 async function metaStoreFactory(loader) {
-  const url = buildURL(loader.ebOpts.store.stores?.meta, loader);
-  ensureName(loader.name, url);
-  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);
-    await store.start();
+  const url2 = buildURL(loader.ebOpts.store.stores?.meta, loader);
+  ensureName(loader.name, url2);
+  const logger = ensureLogger(loader.logger, "metaStoreFactory", { url: () => url2.toString() });
+  url2.searchParams.set("store", "meta");
+  return onceMetaStoreFactory.get(url2.toString()).once(async () => {
+    logger.Debug().Str("protocol", url2.protocol).Msg("pre-protocol switch");
+    const gateway = await loadMetaGateway(url2, logger);
+    const store = new MetaStore(loader.name, url2, loader.logger, gateway);
+    const ret = await store.start();
+    if (ret.isErr()) {
+      throw logger.Error().Result("start", ret).Msg("start failed").AsError();
+    }
     return store;
   });
 }
-var onceWalGateway = new import_cement14.KeyedResolvOnce();
-function loadWalGateway(url, logger) {
-  return onceWalGateway.get(url.protocol).once(async () => {
-    return runStoreFactory(url, logger, async (item) => item.wal(logger));
+var onceWalGateway = new import_cement8.KeyedResolvOnce();
+function loadWalGateway(url2, logger) {
+  return onceWalGateway.get(url2.protocol).once(async () => {
+    return runStoreFactory(url2, logger, async (item) => item.wal(logger));
   });
 }
-var onceRemoteWalFactory = new import_cement14.KeyedResolvOnce();
+var onceRemoteWalFactory = new import_cement8.KeyedResolvOnce();
 async function remoteWalFactory(loader) {
-  const url = buildURL(loader.ebOpts.store.stores?.meta, loader);
-  ensureName(loader.name, url);
-  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();
+  const url2 = buildURL(loader.ebOpts.store.stores?.meta, loader);
+  ensureName(loader.name, url2);
+  const logger = ensureLogger(loader.logger, "remoteWalFactory", { url: url2.toString() });
+  url2.searchParams.set("store", "wal");
+  return onceRemoteWalFactory.get(url2.toString()).once(async () => {
+    const gateway = await loadWalGateway(url2, logger);
+    logger.Debug().Str("prepared", url2.toString()).Msg("produced");
+    const store = new RemoteWAL(loader, url2, loader.logger, gateway);
+    const ret = await store.start();
+    if (ret.isErr()) {
+      throw logger.Error().Result("start", ret).Msg("start failed").AsError();
+    }
     return store;
   });
 }
-async function testStoreFactory(url, ilogger) {
+async function testStoreFactory(url2, ilogger) {
   const logger = ensureLogger(
     {
       logger: ilogger
     },
     "testStoreFactory"
   );
-  return runStoreFactory(url, logger, async (item) => item.test(logger));
+  return runStoreFactory(url2, logger, async (item) => item.test(logger));
 }
 function toStoreRuntime(opts, ilogger) {
   const logger = ensureLogger(ilogger, "toStoreRuntime", {});
@@ -3615,25 +2774,6 @@ registerStoreProtocol({
     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();
@@ -3901,7 +3041,7 @@ 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_utils12 = require("prolly-trees/utils");
 var import_cache2 = require("prolly-trees/cache");
 var IndexTree = class {
 };
@@ -3909,17 +3049,17 @@ function refCompare(aRef, bRef) {
   if (Number.isNaN(aRef)) return -1;
   if (Number.isNaN(bRef)) throw new Error("ref may not be Infinity or NaN");
   if (aRef === Infinity) return 1;
-  return (0, import_utils20.simpleCompare)(aRef, bRef);
+  return (0, import_utils12.simpleCompare)(aRef, bRef);
 }
 function compare(a, b) {
   const [aKey, aRef] = a;
   const [bKey, bRef] = b;
-  const comp = (0, import_utils20.simpleCompare)(aKey, bKey);
+  const comp = (0, import_utils12.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 };
+var byKeyOpts = { cache: import_cache2.nocache, chunker: (0, import_utils12.bf)(30), codec: codec3, hasher: import_sha24.sha256, compare };
+var byIdOpts = { cache: import_cache2.nocache, chunker: (0, import_utils12.bf)(30), codec: codec3, hasher: import_sha24.sha256, compare: import_utils12.simpleCompare };
 function indexEntriesForChanges(changes, mapFn) {
   const indexEntries = [];
   changes.forEach(({ id: key, value, del }) => {
@@ -4227,7 +3367,7 @@ var Index = class {
 // src/crdt-clock.ts
 var import_clock3 = require("@web3-storage/pail/clock");
 var import_crdt2 = require("@web3-storage/pail/crdt");
-var import_cement15 = require("@adviser/cement");
+var import_cement9 = require("@adviser/cement");
 init_types();
 
 // src/apply-head-queue.ts
@@ -4286,7 +3426,7 @@ var CRDTClock = class {
     this.zoomers = /* @__PURE__ */ new Set();
     this.watchers = /* @__PURE__ */ new Set();
     this.emptyWatchers = /* @__PURE__ */ new Set();
-    this._ready = new import_cement15.ResolveOnce();
+    this._ready = new import_cement9.ResolveOnce();
     this.blockstore = blockstore;
     this.logger = ensureLogger(blockstore.logger, "CRDTClock");
     this.applyHeadQueue = applyHeadQueue(this.int_applyHead.bind(this), this.logger);
@@ -4397,7 +3537,7 @@ async function advanceBlocks(logger, newHead, tblocks, head) {
 init_utils();
 var CRDT = class {
   constructor(name, opts = {}) {
-    this.onceReady = new import_cement16.ResolveOnce();
+    this.onceReady = new import_cement10.ResolveOnce();
     this.indexers = /* @__PURE__ */ new Map();
     this.name = name;
     this.logger = ensureLogger(opts, "CRDT");
@@ -4518,7 +3658,7 @@ var Database = class {
     this._listening = false;
     this._listeners = /* @__PURE__ */ new Set();
     this._noupdate_listeners = /* @__PURE__ */ new Set();
-    this._ready = new import_cement17.ResolveOnce();
+    this._ready = new import_cement11.ResolveOnce();
     this.name = name;
     this.opts = opts || this.opts;
     this.logger = ensureLogger(this.opts, "Database");
@@ -4552,9 +3692,9 @@ var Database = class {
     });
   }
   async get(id) {
-    this.logger.Debug().Str("id", id).Msg("get-pre-ready");
+    if (!id) throw this.logger.Error().Str("db", this.name).Msg(`Doc id is required`).AsError();
     await this.ready();
-    this.logger.Debug().Str("id", id).Msg("get-post-ready");
+    this.logger.Debug().Str("id", id).Msg("get");
     const got = await this._crdt.get(id).catch((e) => {
       throw new NotFoundError(`Not found: ${id} - ${e.message}`);
     });
@@ -4563,9 +3703,8 @@ var Database = class {
     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");
+    this.logger.Debug().Str("id", doc._id).Msg("put");
     const { _id, ...value } = doc;
     const docId = _id || (0, import_uuidv73.uuidv7)();
     const result = await this._writeQueue.push({
@@ -4575,36 +3714,40 @@ var Database = class {
         _id: docId
       }
     });
-    return { id: docId, clock: result?.head };
+    return { id: docId, clock: result?.head, name: this.name };
   }
   async del(id) {
     await this.ready();
+    this.logger.Debug().Str("id", id).Msg("del");
     const result = await this._writeQueue.push({ id, del: true });
-    return { id, clock: result?.head };
+    return { id, clock: result?.head, name: this.name };
   }
   async changes(since = [], opts = {}) {
     await this.ready();
+    this.logger.Debug().Any("since", since).Any("opts", opts).Msg("changes");
     const { result, head } = await this._crdt.changes(since, opts);
     const rows = result.map(({ id: key, value, del, clock }) => ({
       key,
       value: del ? { _id: key, _deleted: true } : { _id: key, ...value },
       clock
     }));
-    return { rows, clock: head };
+    return { rows, clock: head, name: this.name };
   }
   async allDocs(opts = {}) {
     await this.ready();
+    this.logger.Debug().Msg("allDocs");
     const { result, head } = await this._crdt.allDocs();
     const rows = result.map(({ id: key, value, del }) => ({
       key,
       value: del ? { _id: key, _deleted: true } : { _id: key, ...value }
     }));
-    return { rows, clock: head };
+    return { rows, clock: head, name: this.name };
   }
   async allDocuments() {
     return this.allDocs();
   }
   subscribe(listener, updates) {
+    this.logger.Debug().Bool("updates", updates).Msg("subscribe");
     if (updates) {
       if (!this._listening) {
         this._listening = true;
@@ -4626,6 +3769,7 @@ var Database = class {
   // 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();
+    this.logger.Debug().Any("field", field).Any("opts", opts).Msg("query");
     const _crdt = this._crdt;
     const idx = typeof field === "string" ? index({ _crdt }, field) : index({ _crdt }, makeName(field.toString()), field);
     return await idx.query(opts);
@@ -4701,6 +3845,6 @@ init_utils();
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.0.0-dev": "xxxx"
+  "0.19.8-dev-getid": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map