@fireproof/core 0.18.0 → 0.19.4-dev

package/dist/node/fireproof.js

@@ -1,1138 +0,0 @@
-// src/database.ts
-import { uuidv7 } from "uuidv7";
-
-// src/write-queue.ts
-function writeQueue(worker, payload = Infinity, unbounded = false) {
-  const queue = [];
-  let isProcessing = false;
-  async function process() {
-    if (isProcessing || queue.length === 0)
-      return;
-    isProcessing = true;
-    const tasksToProcess = queue.splice(0, payload);
-    const updates = tasksToProcess.map((item) => item.task);
-    if (unbounded) {
-      const promises = updates.map(async (update, index2) => {
-        try {
-          const result = await worker([update]);
-          tasksToProcess[index2].resolve(result);
-        } catch (error) {
-          tasksToProcess[index2].reject(error);
-        }
-      });
-      await Promise.all(promises);
-    } else {
-      try {
-        const result = await worker(updates);
-        tasksToProcess.forEach((task) => task.resolve(result));
-      } catch (error) {
-        tasksToProcess.forEach((task) => task.reject(error));
-      }
-    }
-    isProcessing = false;
-    void process();
-  }
-  return {
-    push(task) {
-      return new Promise((resolve, reject) => {
-        queue.push({ task, resolve, reject });
-        void process();
-      });
-    }
-  };
-}
-
-// src/crdt.ts
-import {
-  EncryptedBlockstore
-} from "@fireproof/encrypted-blockstore";
-
-// src/eb-node.ts
-import * as crypto from "@fireproof/encrypted-blockstore/crypto-node";
-import * as store from "@fireproof/encrypted-blockstore/store-node";
-
-// src/crdt-helpers.ts
-import { encode, decode, Block } from "multiformats/block";
-import { parse } from "multiformats/link";
-import { sha256 as hasher } from "multiformats/hashes/sha2";
-import * as codec from "@ipld/dag-cbor";
-import { put, get, entries, root } from "@web3-storage/pail/crdt";
-import { EventFetcher, vis } from "@web3-storage/pail/clock";
-import * as Batch from "@web3-storage/pail/crdt/batch";
-import {
-  CarTransaction
-} from "@fireproof/encrypted-blockstore";
-
-// src/files.ts
-import * as UnixFS from "@ipld/unixfs";
-import * as raw from "multiformats/codecs/raw";
-import { withMaxChunkSize } from "@ipld/unixfs/file/chunker/fixed";
-import { withWidth } from "@ipld/unixfs/file/layout/balanced";
-import { exporter } from "ipfs-unixfs-exporter";
-var queuingStrategy = UnixFS.withCapacity();
-var settings = UnixFS.configure({
-  fileChunkEncoder: raw,
-  smallFileEncoder: raw,
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-  chunker: withMaxChunkSize(1024 * 1024),
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-  fileLayout: withWidth(1024)
-});
-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 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;
-}
-async function collect(collectable) {
-  const chunks = [];
-  await collectable.pipeTo(
-    new WritableStream({
-      write(chunk) {
-        chunks.push(chunk);
-      }
-    })
-  );
-  return chunks;
-}
-var UnixFSFileBuilder = class {
-  #file;
-  name;
-  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/crdt-helpers.ts
-function time(tag) {
-}
-function timeEnd(tag) {
-}
-async function applyBulkUpdateToCrdt(tblocks, head, updates) {
-  let result = null;
-  if (updates.length > 1) {
-    const batch = await Batch.create(tblocks, head);
-    for (const update of updates) {
-      const link = await writeDocContent(tblocks, update);
-      await batch.put(update.key, link);
-    }
-    result = await batch.commit();
-  } else {
-    for (const update of updates) {
-      const link = await writeDocContent(tblocks, update);
-      result = await put(tblocks, head, update.key, link);
-      const resRoot = result.root.toString();
-      const isReturned = result.additions.some((a) => a.cid.toString() === resRoot);
-      if (!isReturned) {
-        const hasRoot = await tblocks.get(result.root);
-        if (!hasRoot) {
-          throw new Error(
-            `missing root in additions: ${result.additions.length} ${resRoot} keys: ${updates.map((u) => u.key).toString()}`
-          );
-        }
-      }
-    }
-  }
-  if (!result)
-    throw new Error("Missing result");
-  if (result.event) {
-    for (const { cid, bytes } of [...result.additions, ...result.removals, result.event]) {
-      tblocks.putSync(cid, bytes);
-    }
-  }
-  return { head: result.head };
-}
-async function writeDocContent(blocks, update) {
-  let value;
-  if (update.del) {
-    value = { del: true };
-  } else {
-    await processFiles(blocks, update.value);
-    value = { doc: update.value };
-  }
-  const block = await encode({ value, hasher, codec });
-  blocks.putSync(block.cid, block.bytes);
-  return block.cid;
-}
-async function processFiles(blocks, doc) {
-  if (doc._files) {
-    await processFileset(blocks, doc._files);
-  }
-  if (doc._publicFiles) {
-    await processFileset(blocks, doc._publicFiles, true);
-  }
-}
-async function processFileset(blocks, files, publicFiles = false) {
-  const dbBlockstore = blocks.parent;
-  const t = new CarTransaction(dbBlockstore);
-  const didPut = [];
-  for (const filename in files) {
-    if (File === files[filename].constructor) {
-      const file = files[filename];
-      const { cid, blocks: fileBlocks } = await encodeFile(file);
-      didPut.push(filename);
-      for (const block of fileBlocks) {
-        t.putSync(block.cid, block.bytes);
-      }
-      files[filename] = { cid, type: file.type, size: file.size };
-    } else {
-      const { cid, type, size, car } = files[filename];
-      if (cid && type && size && car) {
-        files[filename] = { cid, type, size, car };
-      }
-    }
-  }
-  if (didPut.length) {
-    const car = await dbBlockstore.loader?.commitFiles(t, { files }, {
-      public: publicFiles
-    });
-    if (car) {
-      for (const name of didPut) {
-        files[name] = { car, ...files[name] };
-      }
-    }
-  }
-}
-async function getValueFromCrdt(blocks, head, key) {
-  if (!head.length)
-    throw new Error("Getting from an empty database");
-  const link = await get(blocks, head, key);
-  if (!link)
-    throw new Error(`Missing key ${key}`);
-  return await getValueFromLink(blocks, link);
-}
-function readFiles(blocks, { doc }) {
-  if (!doc)
-    return;
-  if (doc._files) {
-    readFileset(blocks, doc._files);
-  }
-  if (doc._publicFiles) {
-    readFileset(blocks, doc._publicFiles, true);
-  }
-}
-function readFileset(blocks, files, isPublic = false) {
-  for (const filename in files) {
-    const fileMeta = files[filename];
-    if (fileMeta.cid) {
-      if (isPublic) {
-        fileMeta.url = `https://${fileMeta.cid.toString()}.ipfs.w3s.link/`;
-      }
-      if (fileMeta.car) {
-        fileMeta.file = async () => await decodeFile(
-          {
-            get: async (cid) => {
-              return await blocks.getFile(fileMeta.car, cid, isPublic);
-            }
-          },
-          fileMeta.cid,
-          fileMeta
-        );
-      }
-    }
-    files[filename] = fileMeta;
-  }
-}
-async function getValueFromLink(blocks, link) {
-  const block = await blocks.get(link);
-  if (!block)
-    throw new Error(`Missing linked block ${link.toString()}`);
-  const { value } = await decode({ bytes: block.bytes, hasher, codec });
-  value.cid = link;
-  readFiles(blocks, value);
-  return value;
-}
-var DirtyEventFetcher = class extends EventFetcher {
-  // @ts-ignore
-  async get(link) {
-    try {
-      return await super.get(link);
-    } catch (e) {
-      console.error("missing event", link.toString(), e);
-      return { value: null };
-    }
-  }
-};
-async function clockChangesSince(blocks, head, since, opts) {
-  const eventsFetcher = opts.dirty ? new DirtyEventFetcher(blocks) : new EventFetcher(blocks);
-  const keys = /* @__PURE__ */ new Set();
-  const updates = await gatherUpdates(
-    blocks,
-    eventsFetcher,
-    head,
-    since,
-    [],
-    keys,
-    /* @__PURE__ */ new Set(),
-    opts.limit || Infinity
-  );
-  return { result: updates.reverse(), head };
-}
-async function gatherUpdates(blocks, eventsFetcher, head, since, updates = [], keys, didLinks, limit) {
-  if (limit <= 0)
-    return updates;
-  const sHead = head.map((l) => l.toString());
-  for (const link of since) {
-    if (sHead.includes(link.toString())) {
-      return updates;
-    }
-  }
-  for (const link of head) {
-    if (didLinks.has(link.toString()))
-      continue;
-    didLinks.add(link.toString());
-    const { value: event } = await eventsFetcher.get(link);
-    if (!event)
-      continue;
-    const { type } = event.data;
-    let ops = [];
-    if (type === "batch") {
-      ops = event.data.ops;
-    } else if (type === "put") {
-      ops = [event.data];
-    }
-    for (let i = ops.length - 1; i >= 0; i--) {
-      const { key, value } = ops[i];
-      if (!keys.has(key)) {
-        const docValue = await getValueFromLink(blocks, value);
-        updates.push({ key, value: docValue.doc, del: docValue.del, clock: link });
-        limit--;
-        keys.add(key);
-      }
-    }
-    if (event.parents) {
-      updates = await gatherUpdates(
-        blocks,
-        eventsFetcher,
-        event.parents,
-        since,
-        updates,
-        keys,
-        didLinks,
-        limit
-      );
-    }
-  }
-  return updates;
-}
-async function* getAllEntries(blocks, head) {
-  for await (const [key, link] of entries(blocks, head)) {
-    const docValue = await getValueFromLink(blocks, link);
-    yield { key, value: docValue.doc, del: docValue.del };
-  }
-}
-async function* clockVis(blocks, head) {
-  for await (const line of vis(blocks, head)) {
-    yield line;
-  }
-}
-var isCompacting = false;
-async function doCompact(blockLog, head) {
-  if (isCompacting) {
-    return;
-  }
-  isCompacting = true;
-  time("compact head");
-  for (const cid of head) {
-    const bl = await blockLog.get(cid);
-    if (!bl)
-      throw new Error("Missing head block: " + cid.toString());
-  }
-  timeEnd("compact head");
-  time("compact all entries");
-  for await (const _entry of getAllEntries(blockLog, head)) {
-  }
-  timeEnd("compact all entries");
-  time("compact clock vis");
-  for await (const _line of vis(blockLog, head)) {
-  }
-  timeEnd("compact clock vis");
-  time("compact root");
-  const result = await root(blockLog, head);
-  timeEnd("compact root");
-  time("compact root blocks");
-  for (const { cid, bytes } of [...result.additions, ...result.removals]) {
-    blockLog.loggedBlocks.putSync(cid, bytes);
-  }
-  timeEnd("compact root blocks");
-  time("compact changes");
-  await clockChangesSince(blockLog, head, [], {});
-  timeEnd("compact changes");
-  isCompacting = false;
-}
-async function getBlock(blocks, cidString) {
-  const block = await blocks.get(parse(cidString));
-  if (!block)
-    throw new Error(`Missing block ${cidString}`);
-  const { cid, value } = await decode({ bytes: block.bytes, codec, hasher });
-  return new Block({ cid, value, bytes: block.bytes });
-}
-
-// src/indexer-helpers.ts
-import { create as create2 } from "multiformats/block";
-import { sha256 as hasher2 } from "multiformats/hashes/sha2";
-import * as codec2 from "@ipld/dag-cbor";
-import charwise from "charwise";
-import * as DbIndex from "prolly-trees/db-index";
-import { bf, simpleCompare } from "prolly-trees/utils";
-import { nocache as cache } from "prolly-trees/cache";
-var IndexTree = class {
-  cid = null;
-  root = null;
-};
-var 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 simpleCompare(aRef, bRef);
-};
-var compare = (a, b) => {
-  const [aKey, aRef] = a;
-  const [bKey, bRef] = b;
-  const comp = simpleCompare(aKey, bKey);
-  if (comp !== 0)
-    return comp;
-  return refCompare(aRef, bRef);
-};
-var byKeyOpts = { cache, chunker: bf(30), codec: codec2, hasher: hasher2, compare };
-var byIdOpts = { cache, chunker: bf(30), codec: codec2, hasher: hasher2, compare: simpleCompare };
-function indexEntriesForChanges(changes, mapFn) {
-  const indexEntries = [];
-  changes.forEach(({ key: _id, value, del }) => {
-    if (del || !value)
-      return;
-    let mapCalled = false;
-    const mapReturn = mapFn({ _id, ...value }, (k, v) => {
-      mapCalled = true;
-      if (typeof k === "undefined")
-        return;
-      indexEntries.push({
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-        key: [charwise.encode(k), _id],
-        value: v || null
-      });
-    });
-    if (!mapCalled && mapReturn) {
-      indexEntries.push({
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-        key: [charwise.encode(mapReturn), _id],
-        value: null
-      });
-    }
-  });
-  return indexEntries;
-}
-function makeProllyGetBlock(blocks) {
-  return async (address) => {
-    const block = await blocks.get(address);
-    if (!block)
-      throw new Error(`Missing block ${address.toString()}`);
-    const { cid, bytes } = block;
-    return create2({ cid, bytes, hasher: hasher2, codec: codec2 });
-  };
-}
-async function bulkIndex(tblocks, inIndex, indexEntries, opts) {
-  if (!indexEntries.length)
-    return inIndex;
-  if (!inIndex.root) {
-    if (!inIndex.cid) {
-      let returnRootBlock = null;
-      let returnNode = null;
-      for await (const node of await DbIndex.create({ get: makeProllyGetBlock(tblocks), list: indexEntries, ...opts })) {
-        const block = await node.block;
-        await tblocks.put(block.cid, block.bytes);
-        returnRootBlock = block;
-        returnNode = node;
-      }
-      if (!returnNode || !returnRootBlock)
-        throw new Error("failed to create index");
-      return { root: returnNode, cid: returnRootBlock.cid };
-    } else {
-      inIndex.root = await DbIndex.load({ cid: inIndex.cid, get: makeProllyGetBlock(tblocks), ...opts });
-    }
-  }
-  const { root: root3, blocks: newBlocks } = await inIndex.root.bulk(indexEntries);
-  if (root3) {
-    for await (const block of newBlocks) {
-      await tblocks.put(block.cid, block.bytes);
-    }
-    return { root: root3, cid: (await root3.block).cid };
-  } else {
-    return { root: null, cid: null };
-  }
-}
-async function loadIndex(tblocks, cid, opts) {
-  return await DbIndex.load({ cid, get: makeProllyGetBlock(tblocks), ...opts });
-}
-async function applyQuery(crdt, resp, query) {
-  if (query.descending) {
-    resp.result = resp.result.reverse();
-  }
-  if (query.limit) {
-    resp.result = resp.result.slice(0, query.limit);
-  }
-  if (query.includeDocs) {
-    resp.result = await Promise.all(
-      resp.result.map(async (row) => {
-        const val = await crdt.get(row.id);
-        const doc = val ? { _id: row.id, ...val.doc } : null;
-        return { ...row, doc };
-      })
-    );
-  }
-  return {
-    rows: resp.result.map((row) => {
-      row.key = charwise.decode(row.key);
-      if (row.row && !row.value) {
-        row.value = row.row;
-        delete row.row;
-      }
-      return row;
-    })
-  };
-}
-function encodeRange(range) {
-  return range.map((key) => charwise.encode(key));
-}
-function encodeKey(key) {
-  return charwise.encode(key);
-}
-
-// src/index.ts
-function index({ _crdt }, name, mapFn, meta) {
-  if (mapFn && meta)
-    throw new Error("cannot provide both mapFn and meta");
-  if (mapFn && mapFn.constructor.name !== "Function")
-    throw new Error("mapFn must be a function");
-  if (_crdt.indexers.has(name)) {
-    const idx = _crdt.indexers.get(name);
-    idx.applyMapFn(name, mapFn, meta);
-  } else {
-    const idx = new Index(_crdt, name, mapFn, meta);
-    _crdt.indexers.set(name, idx);
-  }
-  return _crdt.indexers.get(name);
-}
-var Index = class {
-  blockstore;
-  crdt;
-  name = null;
-  mapFn = null;
-  mapFnString = "";
-  byKey = new IndexTree();
-  byId = new IndexTree();
-  indexHead = void 0;
-  includeDocsDefault = false;
-  initError = null;
-  ready;
-  constructor(crdt, name, mapFn, meta) {
-    this.blockstore = crdt.indexBlockstore;
-    this.crdt = crdt;
-    this.applyMapFn(name, mapFn, meta);
-    if (!(this.mapFnString || this.initError))
-      throw new Error("missing mapFnString");
-    this.ready = this.blockstore.ready.then(() => {
-    });
-  }
-  applyMapFn(name, mapFn, meta) {
-    if (mapFn && meta)
-      throw new Error("cannot provide both mapFn and meta");
-    if (this.name && this.name !== name)
-      throw new Error("cannot change name");
-    this.name = name;
-    try {
-      if (meta) {
-        if (this.indexHead && this.indexHead.map((c) => c.toString()).join() !== meta.head.map((c) => c.toString()).join()) {
-          throw new Error("cannot apply meta to existing index");
-        }
-        if (this.mapFnString) {
-          if (this.mapFnString !== meta.map) {
-            console.log(
-              "cannot apply different mapFn meta: old mapFnString",
-              this.mapFnString,
-              "new mapFnString",
-              meta.map
-            );
-          } else {
-            this.byId.cid = meta.byId;
-            this.byKey.cid = meta.byKey;
-            this.indexHead = meta.head;
-          }
-        } else {
-          this.mapFnString = meta.map;
-          this.byId.cid = meta.byId;
-          this.byKey.cid = meta.byKey;
-          this.indexHead = meta.head;
-        }
-      } else {
-        if (this.mapFn) {
-          if (mapFn) {
-            if (this.mapFn.toString() !== mapFn.toString())
-              throw new Error("cannot apply different mapFn app2");
-          }
-        } else {
-          if (!mapFn) {
-            mapFn = (doc) => doc[name] ?? void 0;
-          }
-          if (this.mapFnString) {
-            if (this.mapFnString !== mapFn.toString())
-              throw new Error("cannot apply different mapFn app");
-          } else {
-            this.mapFnString = mapFn.toString();
-          }
-          this.mapFn = mapFn;
-        }
-      }
-      const matches = /=>\s*(.*)/.test(this.mapFnString);
-      this.includeDocsDefault = matches;
-    } catch (e) {
-      this.initError = e;
-    }
-  }
-  async query(opts = {}) {
-    await this._updateIndex();
-    await this._hydrateIndex();
-    if (!this.byKey.root)
-      return await applyQuery(this.crdt, { result: [] }, opts);
-    if (this.includeDocsDefault && opts.includeDocs === void 0)
-      opts.includeDocs = true;
-    if (opts.range) {
-      const { result: result2, ...all2 } = await this.byKey.root.range(...encodeRange(opts.range));
-      return await applyQuery(this.crdt, { result: result2, ...all2 }, opts);
-    }
-    if (opts.key) {
-      const encodedKey = encodeKey(opts.key);
-      return await applyQuery(this.crdt, await this.byKey.root.get(encodedKey), opts);
-    }
-    if (Array.isArray(opts.keys)) {
-      const results = await Promise.all(
-        opts.keys.map(async (key) => {
-          const encodedKey = encodeKey(key);
-          return (await applyQuery(this.crdt, await this.byKey.root.get(encodedKey), opts)).rows;
-        })
-      );
-      return { rows: results.flat() };
-    }
-    if (opts.prefix) {
-      if (!Array.isArray(opts.prefix))
-        opts.prefix = [opts.prefix];
-      const start = [...opts.prefix, NaN];
-      const end = [...opts.prefix, Infinity];
-      const encodedR = encodeRange([start, end]);
-      return await applyQuery(this.crdt, await this.byKey.root.range(...encodedR), opts);
-    }
-    const { result, ...all } = await this.byKey.root.getAllEntries();
-    return await applyQuery(
-      this.crdt,
-      {
-        result: result.map(({ key: [k, id], value }) => ({ key: k, id, value })),
-        ...all
-      },
-      opts
-    );
-  }
-  _resetIndex() {
-    this.byId = new IndexTree();
-    this.byKey = new IndexTree();
-    this.indexHead = void 0;
-  }
-  async _hydrateIndex() {
-    if (this.byId.root && this.byKey.root)
-      return;
-    if (!this.byId.cid || !this.byKey.cid)
-      return;
-    this.byId.root = await loadIndex(this.blockstore, this.byId.cid, byIdOpts);
-    this.byKey.root = await loadIndex(this.blockstore, this.byKey.cid, byKeyOpts);
-  }
-  async _updateIndex() {
-    await this.ready;
-    if (this.initError)
-      throw this.initError;
-    if (!this.mapFn)
-      throw new Error("No map function defined");
-    let result, head;
-    if (!this.indexHead || this.indexHead.length === 0) {
-      ;
-      ({ result, head } = await this.crdt.allDocs());
-    } else {
-      ;
-      ({ result, head } = await this.crdt.changes(this.indexHead));
-    }
-    if (result.length === 0) {
-      this.indexHead = head;
-      return { byId: this.byId, byKey: this.byKey };
-    }
-    let staleKeyIndexEntries = [];
-    let removeIdIndexEntries = [];
-    if (this.byId.root) {
-      const removeIds = result.map(({ key }) => key);
-      const { result: oldChangeEntries } = await this.byId.root.getMany(removeIds);
-      staleKeyIndexEntries = oldChangeEntries.map((key) => ({ key, del: true }));
-      removeIdIndexEntries = oldChangeEntries.map((key) => ({ key: key[1], del: true }));
-    }
-    const indexEntries = indexEntriesForChanges(result, this.mapFn);
-    const byIdIndexEntries = indexEntries.map(({ key }) => ({
-      key: key[1],
-      value: key
-    }));
-    const indexerMeta = { indexes: /* @__PURE__ */ new Map() };
-    for (const [name, indexer] of this.crdt.indexers) {
-      if (indexer.indexHead) {
-        indexerMeta.indexes.set(name, {
-          byId: indexer.byId.cid,
-          byKey: indexer.byKey.cid,
-          head: indexer.indexHead,
-          map: indexer.mapFnString,
-          name: indexer.name
-        });
-      }
-    }
-    return await this.blockstore.transaction(async (tblocks) => {
-      this.byId = await bulkIndex(
-        tblocks,
-        this.byId,
-        removeIdIndexEntries.concat(byIdIndexEntries),
-        byIdOpts
-      );
-      this.byKey = await bulkIndex(
-        tblocks,
-        this.byKey,
-        staleKeyIndexEntries.concat(indexEntries),
-        byKeyOpts
-      );
-      this.indexHead = head;
-      const idxMeta = {
-        byId: this.byId.cid,
-        byKey: this.byKey.cid,
-        head,
-        map: this.mapFnString,
-        name: this.name
-      };
-      indexerMeta.indexes.set(this.name, idxMeta);
-      return indexerMeta;
-    });
-  }
-};
-
-// src/crdt-clock.ts
-import { advance } from "@web3-storage/pail/clock";
-import { root as root2 } from "@web3-storage/pail/crdt";
-
-// src/apply-head-queue.ts
-function applyHeadQueue(worker) {
-  const queue = [];
-  let isProcessing = false;
-  async function* process() {
-    if (isProcessing || queue.length === 0)
-      return;
-    isProcessing = true;
-    const allUpdates = [];
-    try {
-      while (queue.length > 0) {
-        queue.sort((a, b) => b.updates ? 1 : -1);
-        const task = queue.shift();
-        if (!task)
-          continue;
-        await worker(task.newHead, task.prevHead, task.updates !== null).catch((e) => {
-          console.error("int_applyHead worker error", e);
-          throw e;
-        });
-        if (task.updates) {
-          allUpdates.push(...task.updates);
-        }
-        if (!queue.some((t) => t.updates) || task.updates) {
-          const allTasksHaveUpdates = queue.every((task2) => task2.updates !== null);
-          yield { updates: allUpdates, all: allTasksHaveUpdates };
-          allUpdates.length = 0;
-        }
-      }
-    } finally {
-      isProcessing = false;
-      const generator = process();
-      let result = await generator.next();
-      while (!result.done) {
-        result = await generator.next();
-      }
-    }
-  }
-  return {
-    push(task) {
-      queue.push(task);
-      return process();
-    },
-    size() {
-      return queue.length;
-    }
-  };
-}
-
-// src/crdt-clock.ts
-var CRDTClock = class {
-  // todo: track local and remote clocks independently, merge on read
-  // that way we can drop the whole remote if we need to
-  // should go with making sure the local clock only references locally available blockstore on write
-  head = [];
-  zoomers = /* @__PURE__ */ new Set();
-  watchers = /* @__PURE__ */ new Set();
-  emptyWatchers = /* @__PURE__ */ new Set();
-  blockstore = null;
-  applyHeadQueue;
-  constructor() {
-    this.applyHeadQueue = applyHeadQueue(this.int_applyHead.bind(this));
-  }
-  setHead(head) {
-    this.head = head;
-  }
-  async applyHead(newHead, prevHead, updates = null) {
-    for await (const { updates: updatesAcc, all } of this.applyHeadQueue.push({
-      newHead,
-      prevHead,
-      updates
-    })) {
-      this.processUpdates(updatesAcc, all, prevHead);
-    }
-  }
-  async processUpdates(updatesAcc, all, prevHead) {
-    let internalUpdates = updatesAcc;
-    if (this.watchers.size && !all) {
-      const changes = await clockChangesSince(this.blockstore, this.head, prevHead, {});
-      internalUpdates = changes.result;
-    }
-    this.zoomers.forEach((fn) => fn());
-    this.notifyWatchers(internalUpdates || []);
-  }
-  notifyWatchers(updates) {
-    this.emptyWatchers.forEach((fn) => fn());
-    this.watchers.forEach((fn) => fn(updates || []));
-  }
-  onTick(fn) {
-    this.watchers.add(fn);
-  }
-  onTock(fn) {
-    this.emptyWatchers.add(fn);
-  }
-  onZoom(fn) {
-    this.zoomers.add(fn);
-  }
-  async int_applyHead(newHead, prevHead, localUpdates) {
-    const ogHead = sortClockHead(this.head);
-    newHead = sortClockHead(newHead);
-    if (compareClockHeads(ogHead, newHead)) {
-      return;
-    }
-    const ogPrev = sortClockHead(prevHead);
-    if (compareClockHeads(ogHead, ogPrev)) {
-      this.setHead(newHead);
-      return;
-    }
-    let head = this.head;
-    const noLoader = !localUpdates;
-    if (!this.blockstore)
-      throw new Error("missing blockstore");
-    await validateBlocks(newHead, this.blockstore);
-    await this.blockstore.transaction(
-      async (tblocks) => {
-        head = await advanceBlocks(newHead, tblocks, head);
-        const result = await root2(tblocks, head);
-        for (const { cid, bytes } of [...result.additions, ...result.removals]) {
-          tblocks.putSync(cid, bytes);
-        }
-        return { head };
-      },
-      { noLoader }
-    );
-    this.setHead(head);
-  }
-};
-function sortClockHead(clockHead) {
-  return clockHead.sort((a, b) => a.toString().localeCompare(b.toString()));
-}
-async function validateBlocks(newHead, blockstore) {
-  newHead.map(async (cid) => {
-    const got = await blockstore.get(cid);
-    if (!got) {
-      throw new Error("int_applyHead missing block: " + cid.toString());
-    }
-  });
-}
-function compareClockHeads(head1, head2) {
-  return head1.toString() === head2.toString();
-}
-async function advanceBlocks(newHead, tblocks, head) {
-  for (const cid of newHead) {
-    try {
-      head = await advance(tblocks, head, cid);
-    } catch (e) {
-      continue;
-    }
-  }
-  return head;
-}
-
-// src/crdt.ts
-var CRDT = class {
-  name;
-  opts = {};
-  ready;
-  blockstore;
-  indexBlockstore;
-  indexers = /* @__PURE__ */ new Map();
-  clock = new CRDTClock();
-  constructor(name, opts) {
-    this.name = name || null;
-    this.opts = opts || this.opts;
-    this.blockstore = new EncryptedBlockstore({
-      name,
-      applyMeta: async (meta) => {
-        const crdtMeta = meta;
-        await this.clock.applyHead(crdtMeta.head, []);
-      },
-      compact: async (blocks) => {
-        await doCompact(blocks, this.clock.head);
-        return { head: this.clock.head };
-      },
-      autoCompact: this.opts.autoCompact || 100,
-      crypto: this.opts.crypto || crypto,
-      store: this.opts.store || store,
-      public: this.opts.public,
-      meta: this.opts.meta
-    });
-    this.clock.blockstore = this.blockstore;
-    this.indexBlockstore = new EncryptedBlockstore({
-      name: this.opts.persistIndexes && this.name ? this.name + ".idx" : void 0,
-      applyMeta: async (meta) => {
-        const idxCarMeta = meta;
-        for (const [name2, idx] of Object.entries(idxCarMeta.indexes)) {
-          index({ _crdt: this }, name2, void 0, idx);
-        }
-      },
-      crypto,
-      public: this.opts.public,
-      store
-    });
-    this.ready = Promise.all([this.blockstore.ready, this.indexBlockstore.ready]).then(() => {
-    });
-    this.clock.onZoom(() => {
-      for (const idx of this.indexers.values()) {
-        idx._resetIndex();
-      }
-    });
-  }
-  async bulk(updates) {
-    await this.ready;
-    const prevHead = [...this.clock.head];
-    const meta = await this.blockstore.transaction(
-      async (blocks) => {
-        const { head } = await applyBulkUpdateToCrdt(blocks, this.clock.head, updates);
-        updates = updates.map(({ key, value, del, clock }) => {
-          readFiles(this.blockstore, { doc: value });
-          return { key, value, del, clock };
-        });
-        return { head };
-      }
-    );
-    await this.clock.applyHead(meta.head, prevHead, updates);
-    return meta;
-  }
-  // if (snap) await this.clock.applyHead(crdtMeta.head, this.clock.head)
-  async allDocs() {
-    await this.ready;
-    const result = [];
-    for await (const entry of getAllEntries(this.blockstore, this.clock.head)) {
-      result.push(entry);
-    }
-    return { result, head: this.clock.head };
-  }
-  async vis() {
-    await this.ready;
-    const txt = [];
-    for await (const line of clockVis(this.blockstore, this.clock.head)) {
-      txt.push(line);
-    }
-    return txt.join("\n");
-  }
-  async getBlock(cidString) {
-    await this.ready;
-    return await getBlock(this.blockstore, cidString);
-  }
-  async get(key) {
-    await this.ready;
-    const result = await getValueFromCrdt(this.blockstore, this.clock.head, key);
-    if (result.del)
-      return null;
-    return result;
-  }
-  async changes(since = [], opts = {}) {
-    await this.ready;
-    return await clockChangesSince(this.blockstore, this.clock.head, since, opts);
-  }
-  async compact() {
-    return await this.blockstore.compact();
-  }
-};
-
-// src/database.ts
-var Database = class {
-  static databases = /* @__PURE__ */ new Map();
-  name;
-  opts = {};
-  _listening = false;
-  _listeners = /* @__PURE__ */ new Set();
-  _noupdate_listeners = /* @__PURE__ */ new Set();
-  _crdt;
-  _writeQueue;
-  blockstore;
-  constructor(name, opts) {
-    this.name = name || null;
-    this.opts = opts || this.opts;
-    this._crdt = new CRDT(name, this.opts);
-    this.blockstore = this._crdt.blockstore;
-    this._writeQueue = writeQueue(async (updates) => {
-      return await this._crdt.bulk(updates);
-    });
-    this._crdt.clock.onTock(() => {
-      this._no_update_notify();
-    });
-  }
-  async get(id) {
-    const got = await this._crdt.get(id).catch((e) => {
-      e.message = `Not found: ${id} - ` + e.message;
-      throw e;
-    });
-    if (!got)
-      throw new Error(`Not found: ${id}`);
-    const { doc } = got;
-    return { _id: id, ...doc };
-  }
-  async put(doc) {
-    const { _id, ...value } = doc;
-    const docId = _id || uuidv7();
-    const result = await this._writeQueue.push({ key: docId, value });
-    return { id: docId, clock: result?.head };
-  }
-  async del(id) {
-    const result = await this._writeQueue.push({ key: id, del: true });
-    return { id, clock: result?.head };
-  }
-  async changes(since = [], opts = {}) {
-    const { result, head } = await this._crdt.changes(since, opts);
-    const rows = result.map(({ key, value, del, clock }) => ({
-      key,
-      value: del ? { _id: key, _deleted: true } : { _id: key, ...value },
-      clock
-    }));
-    return { rows, clock: head };
-  }
-  async allDocs() {
-    const { result, head } = await this._crdt.allDocs();
-    const rows = result.map(({ key, value, del }) => ({
-      key,
-      value: del ? { _id: key, _deleted: true } : { _id: key, ...value }
-    }));
-    return { rows, clock: head };
-  }
-  async allDocuments() {
-    return this.allDocs();
-  }
-  subscribe(listener, updates) {
-    if (updates) {
-      if (!this._listening) {
-        this._listening = true;
-        this._crdt.clock.onTick((updates2) => {
-          void this._notify(updates2);
-        });
-      }
-      this._listeners.add(listener);
-      return () => {
-        this._listeners.delete(listener);
-      };
-    } else {
-      this._noupdate_listeners.add(listener);
-      return () => {
-        this._noupdate_listeners.delete(listener);
-      };
-    }
-  }
-  // todo if we add this onto dbs in fireproof.ts then we can make index.ts a separate package
-  async query(field, opts = {}) {
-    const idx = typeof field === "string" ? index({ _crdt: this._crdt }, field) : index({ _crdt: this._crdt }, makeName(field.toString()), field);
-    return await idx.query(opts);
-  }
-  async compact() {
-    await this._crdt.compact();
-  }
-  async _notify(updates) {
-    if (this._listeners.size) {
-      const docs = updates.map(({ key, value }) => ({ _id: key, ...value }));
-      for (const listener of this._listeners) {
-        await (async () => await listener(docs))().catch((e) => {
-          console.error("subscriber error", e);
-        });
-      }
-    }
-  }
-  async _no_update_notify() {
-    if (this._noupdate_listeners.size) {
-      for (const listener of this._noupdate_listeners) {
-        await (async () => await listener([]))().catch((e) => {
-          console.error("subscriber error", e);
-        });
-      }
-    }
-  }
-};
-function fireproof(name, opts) {
-  if (!Database.databases.has(name)) {
-    Database.databases.set(name, new Database(name, opts));
-  }
-  return Database.databases.get(name);
-}
-function makeName(fnString) {
-  const regex = /\(([^,()]+,\s*[^,()]+|\[[^\]]+\],\s*[^,()]+)\)/g;
-  let found = null;
-  const matches = Array.from(fnString.matchAll(regex), (match) => match[1].trim());
-  if (matches.length === 0) {
-    found = /=>\s*(.*)/.exec(fnString);
-  }
-  if (!found) {
-    return fnString;
-  } else {
-    return found[1];
-  }
-}
-export {
-  Database,
-  fireproof
-};
-//# sourceMappingURL=fireproof.js.map