@fireproof/core 0.19.5-dev → 0.19.8-dev-alldocs

package/index.cjs

@@ -225,10 +225,6 @@ var init_sys_container = __esm({
 
 // src/runtime/data-dir.ts
 function dataDir(name, base) {
-  const dataDir2 = _dataDir(name, base);
-  return dataDir2;
-}
-function _dataDir(name, base) {
   if (!base) {
     if (import_std_env.isNode || import_std_env.isDeno) {
       base = SysContainer.env.get("FP_STORAGE_URL") || `file://${SysContainer.join(SysContainer.homedir(), ".fireproof")}`;
@@ -298,6 +294,203 @@ 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, {
+  toCryptoOpts: () => toCryptoOpts
+});
+function randomBytes(size) {
+  const bytes = new Uint8Array(size);
+  if (size > 0) {
+    crypto.getRandomValues(bytes);
+  }
+  return bytes;
+}
+function digestSHA256(data) {
+  return Promise.resolve(crypto.subtle.digest("SHA-256", data));
+}
+function toCryptoOpts(cryptoOpts = {}) {
+  const opts = {
+    importKey: cryptoOpts.importKey || crypto.subtle.importKey.bind(crypto.subtle),
+    encrypt: cryptoOpts.encrypt || crypto.subtle.encrypt.bind(crypto.subtle),
+    decrypt: cryptoOpts.decrypt || crypto.subtle.decrypt.bind(crypto.subtle),
+    randomBytes: cryptoOpts.randomBytes || randomBytes,
+    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256
+  };
+  return opts;
+}
+var init_crypto = __esm({
+  "src/runtime/crypto.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/files.ts
+var files_exports = {};
+__export(files_exports, {
+  decodeFile: () => decodeFile,
+  encodeFile: () => encodeFile
+});
+async function collect(collectable) {
+  const chunks = [];
+  await collectable.pipeTo(
+    new WritableStream({
+      write(chunk) {
+        chunks.push(chunk);
+      }
+    })
+  );
+  return chunks;
+}
+async function encodeFile(blob) {
+  const readable = createFileEncoderStream(blob);
+  const blocks = await collect(readable);
+  return { cid: blocks.at(-1).cid, blocks };
+}
+async function decodeFile(blocks, cid, meta) {
+  const entry = await (0, import_ipfs_unixfs_exporter.exporter)(cid.toString(), blocks, { length: meta.size });
+  const chunks = [];
+  for await (const chunk of entry.content()) {
+    chunks.push(chunk);
+  }
+  return new File(chunks, entry.name, { type: meta.type, lastModified: 0 });
+}
+function createFileEncoderStream(blob) {
+  const { readable, writable } = new TransformStream({}, queuingStrategy);
+  const unixfsWriter = UnixFS.createWriter({ writable, settings });
+  const fileBuilder = new UnixFSFileBuilder("", blob);
+  void (async () => {
+    await fileBuilder.finalize(unixfsWriter);
+    await unixfsWriter.close();
+  })();
+  return readable;
+}
+var UnixFS, raw, import_fixed, import_balanced, import_ipfs_unixfs_exporter, queuingStrategy, settings, UnixFSFileBuilder;
+var init_files = __esm({
+  "src/runtime/files.ts"() {
+    "use strict";
+    UnixFS = __toESM(require("@ipld/unixfs"), 1);
+    raw = __toESM(require("multiformats/codecs/raw"), 1);
+    import_fixed = require("@ipld/unixfs/file/chunker/fixed");
+    import_balanced = require("@ipld/unixfs/file/layout/balanced");
+    import_ipfs_unixfs_exporter = require("ipfs-unixfs-exporter");
+    queuingStrategy = UnixFS.withCapacity();
+    settings = UnixFS.configure({
+      fileChunkEncoder: raw,
+      smallFileEncoder: raw,
+      chunker: (0, import_fixed.withMaxChunkSize)(1024 * 1024),
+      fileLayout: (0, import_balanced.withWidth)(1024)
+    });
+    UnixFSFileBuilder = class {
+      #file;
+      constructor(name, file) {
+        this.name = name;
+        this.#file = file;
+      }
+      async finalize(writer) {
+        const unixfsFileWriter = UnixFS.createFileWriter(writer);
+        await this.#file.stream().pipeTo(
+          new WritableStream({
+            async write(chunk) {
+              await unixfsFileWriter.write(chunk);
+            }
+          })
+        );
+        return await unixfsFileWriter.close();
+      }
+    };
+  }
+});
+
 // src/runtime/store-file-version.ts
 var FILESTORE_VERSION;
 var init_store_file_version = __esm({
@@ -332,11 +525,14 @@ __export(runtime_exports, {
   INDEXDB_VERSION: () => INDEXDB_VERSION,
   SQLITE_VERSION: () => SQLITE_VERSION,
   SysContainer: () => SysContainer,
+  crypto: () => crypto_exports,
   dataDir: () => dataDir,
   ensureIndexName: () => ensureIndexName,
+  files: () => files_exports,
   getFileName: () => getFileName,
   getPath: () => getPath,
-  join: () => join
+  join: () => join,
+  sql: () => store_sql_exports
 });
 var init_runtime = __esm({
   "src/runtime/index.ts"() {
@@ -344,6 +540,9 @@ 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();
@@ -863,81 +1062,6 @@ var init_store_file = __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 || textEncoder2;
-}
-function ensureTextDecoder(opts) {
-  return opts?.textDecoder || textDecoder2;
-}
-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 textEncoder2, textDecoder2;
-var init_ensurer = __esm({
-  "src/runtime/store-sql/ensurer.ts"() {
-    "use strict";
-    init_utils();
-    init_types2();
-    textEncoder2 = new TextEncoder();
-    textDecoder2 = new TextDecoder();
-  }
-});
-
 // src/runtime/store-sql/sqlite-adapter-better-sqlite3.ts
 var import_cement8, onceSQLiteConnections, SQLiteConnection;
 var init_sqlite_adapter_better_sqlite3 = __esm({
@@ -1479,15 +1603,15 @@ var init_store_version_factory = __esm({
 });
 
 // src/runtime/store-sql/store-sql.ts
-var store_sql_exports = {};
-__export(store_sql_exports, {
+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_sql = __esm({
+var init_store_sql2 = __esm({
   "src/runtime/store-sql/store-sql.ts"() {
     "use strict";
     import_cement13 = require("@adviser/cement");
@@ -1733,6 +1857,7 @@ __export(src_exports, {
   index: () => index,
   isFalsy: () => isFalsy,
   rt: () => runtime_exports,
+  runtime: () => runtime_exports,
   throwFalsy: () => throwFalsy
 });
 module.exports = __toCommonJS(src_exports);
@@ -1992,72 +2117,7 @@ var ConnectREST = class extends ConnectionBase {
 // src/blockstore/store-factory.ts
 var import_cement14 = require("@adviser/cement");
 init_data_dir();
-
-// src/runtime/files.ts
-var UnixFS = __toESM(require("@ipld/unixfs"), 1);
-var raw = __toESM(require("multiformats/codecs/raw"), 1);
-var import_fixed = require("@ipld/unixfs/file/chunker/fixed");
-var import_balanced = require("@ipld/unixfs/file/layout/balanced");
-var import_ipfs_unixfs_exporter = require("ipfs-unixfs-exporter");
-var queuingStrategy = UnixFS.withCapacity();
-var settings = UnixFS.configure({
-  fileChunkEncoder: raw,
-  smallFileEncoder: raw,
-  chunker: (0, import_fixed.withMaxChunkSize)(1024 * 1024),
-  fileLayout: (0, import_balanced.withWidth)(1024)
-});
-async function collect(collectable) {
-  const chunks = [];
-  await collectable.pipeTo(
-    new WritableStream({
-      write(chunk) {
-        chunks.push(chunk);
-      }
-    })
-  );
-  return chunks;
-}
-async function encodeFile(blob) {
-  const readable = createFileEncoderStream(blob);
-  const blocks = await collect(readable);
-  return { cid: blocks.at(-1).cid, blocks };
-}
-async function decodeFile(blocks, cid, meta) {
-  const entry = await (0, import_ipfs_unixfs_exporter.exporter)(cid.toString(), blocks, { length: meta.size });
-  const chunks = [];
-  for await (const chunk of entry.content()) {
-    chunks.push(chunk);
-  }
-  return new File(chunks, entry.name, { type: meta.type, lastModified: 0 });
-}
-function createFileEncoderStream(blob) {
-  const { readable, writable } = new TransformStream({}, queuingStrategy);
-  const unixfsWriter = UnixFS.createWriter({ writable, settings });
-  const fileBuilder = new UnixFSFileBuilder("", blob);
-  void (async () => {
-    await fileBuilder.finalize(unixfsWriter);
-    await unixfsWriter.close();
-  })();
-  return readable;
-}
-var UnixFSFileBuilder = class {
-  #file;
-  constructor(name, file) {
-    this.name = name;
-    this.#file = file;
-  }
-  async finalize(writer) {
-    const unixfsFileWriter = UnixFS.createFileWriter(writer);
-    await this.#file.stream().pipeTo(
-      new WritableStream({
-        async write(chunk) {
-          await unixfsFileWriter.write(chunk);
-        }
-      })
-    );
-    return await unixfsFileWriter.close();
-  }
-};
+init_files();
 
 // src/blockstore/store.ts
 var import_p_limit2 = __toESM(require("p-limit"), 1);
@@ -2127,7 +2187,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_utils7 = require("prolly-trees/utils");
+var import_utils8 = require("prolly-trees/utils");
 var import_cache = require("prolly-trees/cache");
 var import_cid_set = require("prolly-trees/cid-set");
 
@@ -2315,7 +2375,7 @@ function makeEncDec(logger, crypto2, randomBytes2) {
   };
   return { encrypt, decrypt };
 }
-var chunker = (0, import_utils7.bf)(30);
+var chunker = (0, import_utils8.bf)(30);
 function hexStringToUint8Array(hexString) {
   const length = hexString.length;
   const uint8Array = new Uint8Array(length / 2);
@@ -2380,30 +2440,7 @@ async function decodeCarBlocks(logger, crypto2, root3, get2, keyMaterial) {
 // src/blockstore/transaction.ts
 var import_block5 = require("@web3-storage/pail/block");
 init_types();
-
-// src/runtime/crypto.ts
-function randomBytes(size) {
-  const bytes = new Uint8Array(size);
-  if (size > 0) {
-    crypto.getRandomValues(bytes);
-  }
-  return bytes;
-}
-function digestSHA256(data) {
-  return Promise.resolve(crypto.subtle.digest("SHA-256", data));
-}
-function toCryptoOpts(cryptoOpts = {}) {
-  const opts = {
-    importKey: cryptoOpts.importKey || crypto.subtle.importKey.bind(crypto.subtle),
-    encrypt: cryptoOpts.encrypt || crypto.subtle.encrypt.bind(crypto.subtle),
-    decrypt: cryptoOpts.decrypt || crypto.subtle.decrypt.bind(crypto.subtle),
-    randomBytes: cryptoOpts.randomBytes || randomBytes,
-    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256
-  };
-  return opts;
-}
-
-// src/blockstore/transaction.ts
+init_crypto();
 init_utils();
 var CarTransaction = class extends import_block5.MemoryBlockstore {
   constructor(parent, opts = { add: true }) {
@@ -3071,8 +3108,8 @@ var VersionedStore = class {
     this._onClosed.push(fn);
   }
 };
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
+var textEncoder2 = new TextEncoder();
+var textDecoder2 = new TextDecoder();
 var MetaStore = class extends VersionedStore {
   constructor(name, url, logger, gateway) {
     super(name, url, ensureLogger(logger, "MetaStore", {}));
@@ -3111,7 +3148,7 @@ var MetaStore = class extends VersionedStore {
       throw this.logger.Error().Err(bytes.Err()).Msg("gateway get").AsError();
     }
     try {
-      return [this.parseHeader(textDecoder.decode(bytes.Ok()))];
+      return [this.parseHeader(textDecoder2.decode(bytes.Ok()))];
     } catch (e) {
       throw this.logger.Error().Err(e).Msg("parseHeader").AsError();
     }
@@ -3123,7 +3160,7 @@ var MetaStore = class extends VersionedStore {
     if (url.isErr()) {
       throw this.logger.Error().Err(url.Err()).Str("branch", branch).Url(this.url).Msg("got error from gateway.buildUrl").AsError();
     }
-    const res = await this.gateway.put(url.Ok(), textEncoder.encode(bytes));
+    const res = await this.gateway.put(url.Ok(), textEncoder2.encode(bytes));
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Msg("got error from gateway.put").AsError();
     }
@@ -3363,7 +3400,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)(textDecoder.decode(bytes.Ok()));
+      return bytes && (0, import_dag_json.parse)(textDecoder2.decode(bytes.Ok()));
     } catch (e) {
       throw this.logger.Error().Err(e).Msg("error parse").AsError();
     }
@@ -3379,7 +3416,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(), textEncoder.encode(encoded));
+    const res = await this.gateway.put(filepath.Ok(), textEncoder2.encode(encoded));
     if (res.isErr()) {
       throw this.logger.Error().Err(res.Err()).Str("filePath", filepath.Ok().toString()).Msg("error saving").AsError();
     }
@@ -3415,16 +3452,34 @@ function toURL(pathOrUrl, isIndex) {
     return ensureIsIndex(url, isIndex);
   }
 }
+var storeFactory = /* @__PURE__ */ new Map();
+function ensureName(name, url) {
+  if (!url.searchParams.has("name")) {
+    url.searchParams.set("name", name);
+  }
+}
 function buildURL(optURL, loader) {
   const storeOpts = loader.ebOpts.store;
-  return toURL(optURL || dataDir(loader.name, storeOpts.stores?.base), storeOpts.isIndex);
+  const obuItem = Array.from(storeFactory.values()).find((items) => items.overrideBaseURL);
+  let obuUrl;
+  if (obuItem && obuItem.overrideBaseURL) {
+    obuUrl = new URL(obuItem.overrideBaseURL);
+  }
+  return toURL(optURL || obuUrl || dataDir(loader.name, storeOpts.stores?.base), storeOpts.isIndex);
 }
-var storeFactory = /* @__PURE__ */ new Map();
 function registerStoreProtocol(item) {
   if (storeFactory.has(item.protocol)) {
     throw new Error(`protocol ${item.protocol} already registered`);
   }
+  if (item.overrideBaseURL) {
+    Array.from(storeFactory.values()).forEach((items) => {
+      items.overrideBaseURL = void 0;
+    });
+  }
   storeFactory.set(item.protocol, item);
+  return () => {
+    storeFactory.delete(item.protocol);
+  };
 }
 function runStoreFactory(url, logger, run) {
   const item = storeFactory.get(url.protocol);
@@ -3443,6 +3498,7 @@ function loadDataGateway(url, logger) {
 var onceDataStoreFactory = new import_cement14.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 () => {
@@ -3462,15 +3518,14 @@ function loadMetaGateway(url, logger) {
 var onceMetaStoreFactory = new import_cement14.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);
-    logger.Debug().Msg("pre-start");
     await store.start();
-    logger.Debug().Msg("post-start");
     return store;
   });
 }
@@ -3483,6 +3538,7 @@ function loadWalGateway(url, logger) {
 var onceRemoteWalFactory = new import_cement14.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 () => {
@@ -3562,19 +3618,19 @@ registerStoreProtocol({
 registerStoreProtocol({
   protocol: "sqlite:",
   data: async (logger) => {
-    const { SQLDataGateway: SQLDataGateway2 } = await Promise.resolve().then(() => (init_store_sql(), store_sql_exports));
+    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_sql(), store_sql_exports));
+    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_sql(), store_sql_exports));
+    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_sql(), store_sql_exports));
+    const { SQLTestStore: SQLTestStore2 } = await Promise.resolve().then(() => (init_store_sql2(), store_sql_exports2));
     return new SQLTestStore2(logger);
   }
 });
@@ -4536,7 +4592,7 @@ var Database = class {
     }));
     return { rows, clock: head };
   }
-  async allDocs() {
+  async allDocs(opts = {}) {
     await this.ready();
     const { result, head } = await this._crdt.allDocs();
     const rows = result.map(({ id: key, value, del }) => ({
@@ -4640,10 +4696,11 @@ function makeName(fnString) {
 // src/index.ts
 init_types();
 init_runtime();
+init_runtime();
 init_utils();
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.19.5-dev": "xxxx"
+  "0.0.0-dev": "xxxx"
 })[0];
 //# sourceMappingURL=index.cjs.map