@fireproof/core 0.16.6 → 0.17.0

package/dist/node/fireproof.global.js

@@ -932,7 +932,7 @@ var Fireproof = (() => {
         this.tail = this.head;
         this.states = null;
       }
-      var create14 = function create15() {
+      var create18 = function create19() {
         return util.Buffer ? function create_buffer_setup() {
           return (Writer.create = function create_buffer() {
             return new BufferWriter();
@@ -941,7 +941,7 @@ var Fireproof = (() => {
           return new Writer();
         };
       };
-      Writer.create = create14();
+      Writer.create = create18();
       Writer.alloc = function alloc3(size) {
         return new util.Array(size);
       };
@@ -1087,7 +1087,7 @@ var Fireproof = (() => {
       };
       Writer._configure = function(BufferWriter_) {
         BufferWriter = BufferWriter_;
-        Writer.create = create14();
+        Writer.create = create18();
         BufferWriter._configure();
       };
     }
@@ -1170,14 +1170,14 @@ var Fireproof = (() => {
           return new Reader(buffer2);
         throw Error("illegal buffer");
       };
-      var create14 = function create15() {
+      var create18 = function create19() {
         return util.Buffer ? function create_buffer_setup(buffer2) {
           return (Reader.create = function create_buffer(buffer3) {
             return util.Buffer.isBuffer(buffer3) ? new BufferReader(buffer3) : create_array(buffer3);
           })(buffer2);
         } : create_array;
       };
-      Reader.create = create14();
+      Reader.create = create18();
       Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */
       util.Array.prototype.slice;
       Reader.prototype.uint32 = /* @__PURE__ */ function read_uint32_setup() {
@@ -1345,7 +1345,7 @@ var Fireproof = (() => {
       };
       Reader._configure = function(BufferReader_) {
         BufferReader = BufferReader_;
-        Reader.create = create14();
+        Reader.create = create18();
         BufferReader._configure();
         var fn = util.Long ? "toLong" : (
           /* istanbul ignore next */
@@ -1500,13 +1500,13 @@ var Fireproof = (() => {
       protobuf.util = require_minimal();
       protobuf.rpc = require_rpc();
       protobuf.roots = require_roots();
-      protobuf.configure = configure5;
-      function configure5() {
+      protobuf.configure = configure6;
+      function configure6() {
         protobuf.util._configure();
         protobuf.Writer._configure(protobuf.BufferWriter);
         protobuf.Reader._configure(protobuf.BufferReader);
       }
-      configure5();
+      configure6();
     }
   });
 
@@ -4067,24 +4067,41 @@ var Fireproof = (() => {
   var cidSymbol = Symbol.for("@ipld/js-cid/CID");
 
   // ../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/link.js
+  var isLink = (value) => {
+    if (value == null) {
+      return false;
+    }
+    const withSlash = (
+      /** @type {{'/'?: Uint8Array, bytes: Uint8Array}} */
+      value
+    );
+    if (withSlash["/"] != null && withSlash["/"] === withSlash.bytes) {
+      return true;
+    }
+    const withAsCID = (
+      /** @type {{'asCID'?: unknown}} */
+      value
+    );
+    if (withAsCID.asCID === value) {
+      return true;
+    }
+    return false;
+  };
   var parse = (source, base4) => CID.parse(source, base4);
 
-  // ../../node_modules/.pnpm/@alanshaw+pail@0.3.4/node_modules/@alanshaw/pail/src/block.js
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.0/node_modules/@web3-storage/pail/src/block.js
   var MemoryBlockstore = class {
     /** @type {Map<string, Uint8Array>} */
     #blocks = /* @__PURE__ */ new Map();
     /**
-     * @param {Array<AnyBlock>} [blocks]
+     * @param {Array<import('multiformats').Block>} [blocks]
      */
     constructor(blocks) {
       if (blocks) {
         this.#blocks = new Map(blocks.map((b) => [b.cid.toString(), b.bytes]));
       }
     }
-    /**
-     * @param {import('./link').AnyLink} cid
-     * @returns {Promise<AnyBlock | undefined>}
-     */
+    /** @type {API.BlockFetcher['get']} */
     async get(cid) {
       const bytes = this.#blocks.get(cid.toString());
       if (!bytes)
@@ -4092,24 +4109,24 @@ var Fireproof = (() => {
       return { cid, bytes };
     }
     /**
-     * @param {import('./link').AnyLink} cid
+     * @param {API.UnknownLink} cid
      * @param {Uint8Array} bytes
      */
     async put(cid, bytes) {
       this.#blocks.set(cid.toString(), bytes);
     }
     /**
-     * @param {import('./link').AnyLink} cid
+     * @param {API.UnknownLink} cid
      * @param {Uint8Array} bytes
      */
     putSync(cid, bytes) {
       this.#blocks.set(cid.toString(), bytes);
     }
-    /** @param {import('./link').AnyLink} cid */
+    /** @param {API.UnknownLink} cid */
     async delete(cid) {
       this.#blocks.delete(cid.toString());
     }
-    /** @param {import('./link').AnyLink} cid */
+    /** @param {API.UnknownLink} cid */
     deleteSync(cid) {
       this.#blocks.delete(cid.toString());
     }
@@ -4120,13 +4137,13 @@ var Fireproof = (() => {
     }
   };
   var MultiBlockFetcher = class {
-    /** @type {BlockFetcher[]} */
+    /** @type {API.BlockFetcher[]} */
     #fetchers;
-    /** @param {BlockFetcher[]} fetchers */
+    /** @param {API.BlockFetcher[]} fetchers */
     constructor(...fetchers) {
       this.#fetchers = fetchers;
     }
-    /** @param {import('./link').AnyLink} link */
+    /** @type {API.BlockFetcher['get']} */
     async get(link2) {
       for (const f of this.#fetchers) {
         const v = await f.get(link2);
@@ -4378,10 +4395,10 @@ var Fireproof = (() => {
      * @param {any} [value]
      * @param {number} [encodedLength]
      */
-    constructor(type2, value, encodedLength) {
+    constructor(type2, value, encodedLength2) {
       this.type = type2;
       this.value = value;
-      this.encodedLength = encodedLength;
+      this.encodedLength = encodedLength2;
       this.encodedBytes = void 0;
       this.byteValue = void 0;
     }
@@ -10183,6 +10200,22 @@ You can use close({ resize: true }) to resize header`);
     async commit(t, done, opts = { noLoader: false, compact: false }) {
       return this.commitQueue.enqueue(() => this._commitInternal(t, done, opts));
     }
+    async cacheTransaction(t) {
+      for await (const block of t.entries()) {
+        const sBlock = block.cid.toString();
+        if (!this.getBlockCache.has(sBlock)) {
+          this.getBlockCache.set(sBlock, block);
+        }
+      }
+    }
+    async cacheCarReader(reader) {
+      for await (const block of reader.blocks()) {
+        const sBlock = block.cid.toString();
+        if (!this.getBlockCache.has(sBlock)) {
+          this.getBlockCache.set(sBlock, block);
+        }
+      }
+    }
     async _commitInternal(t, done, opts = { noLoader: false, compact: false }) {
       await this.ready;
       const header = done;
@@ -10190,6 +10223,7 @@ You can use close({ resize: true }) to resize header`);
       let roots = await this.prepareRoots(fp, t);
       const { cid, bytes } = await this.prepareCarFile(roots[0], t, !!opts.public);
       await this.carStore.save({ cid, bytes });
+      await this.cacheTransaction(t);
       const newDbMeta = { car: cid, key: this.key || null };
       await this.remoteWAL.enqueue(newDbMeta, opts);
       await this.metaStore.save(newDbMeta);
@@ -10242,13 +10276,8 @@ You can use close({ resize: true }) to resize header`);
     }
     async *entries() {
       await this.ready;
-      for (const cid of this.carLog) {
-        const reader = await this.loadCar(cid);
-        if (!reader)
-          throw new Error(`missing car reader ${cid.toString()}`);
-        for await (const block of reader.blocks()) {
-          yield block;
-        }
+      for (const [, block] of this.getBlockCache) {
+        yield block;
       }
     }
     async getBlock(cid) {
@@ -10263,10 +10292,9 @@ You can use close({ resize: true }) to resize header`);
           if (!reader) {
             throw new Error(`missing car reader ${carCid.toString()}`);
           }
-          const block = await reader.get(cid);
-          if (block) {
-            return block;
-          }
+          await this.cacheCarReader(reader);
+          if (this.getBlockCache.has(sCid))
+            return this.getBlockCache.get(sCid);
           throw new Error(`block not in reader: ${cid.toString()}`);
         })
       ).catch(() => void 0);
@@ -10319,7 +10347,7 @@ You can use close({ resize: true }) to resize header`);
     }
     async ensureDecryptedReader(reader) {
       const theKey = await this._getKey();
-      if (!(theKey && this.ebOpts.crypto))
+      if (this.ebOpts.public || !(theKey && this.ebOpts.crypto))
         return reader;
       const { blocks, root: root2 } = await decodeEncryptedCar(this.ebOpts.crypto, theKey, reader);
       return {
@@ -10397,8 +10425,10 @@ You can use close({ resize: true }) to resize header`);
         if (this.ebOpts.autoCompact && this.loader.carLog.length > this.ebOpts.autoCompact) {
           setTimeout(() => void this.compact(), 10);
         }
-        if (car)
+        if (car) {
+          this.transactions.delete(t);
           return { ...done, car };
+        }
         throw new Error("failed to commit car");
       }
       return done;
@@ -10449,13 +10479,19 @@ You can use close({ resize: true }) to resize header`);
     }
     async *entries() {
       const seen = /* @__PURE__ */ new Set();
-      for (const t of this.transactions) {
-        for await (const blk of t.entries()) {
-          if (seen.has(blk.cid.toString()))
-            continue;
-          seen.add(blk.cid.toString());
+      if (this.loader) {
+        for await (const blk of this.loader.entries()) {
           yield blk;
         }
+      } else {
+        for (const t of this.transactions) {
+          for await (const blk of t.entries()) {
+            if (seen.has(blk.cid.toString()))
+              continue;
+            seen.add(blk.cid.toString());
+            yield blk;
+          }
+        }
       }
     }
   };
@@ -18999,8 +19035,8 @@ ${key.data.toString("base64")}
     return await (0, import_promises.writeFile)(path, data);
   }
 
-  // ../../node_modules/.pnpm/@alanshaw+pail@0.3.4/node_modules/@alanshaw/pail/src/clock.js
-  async function advance(blocks, head, event) {
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.0/node_modules/@web3-storage/pail/src/clock/index.js
+  var advance = async (blocks, head, event) => {
     const events = new EventFetcher(blocks);
     const headmap = new Map(head.map((cid) => [cid.toString(), cid]));
     if (headmap.has(event.toString()))
@@ -19022,11 +19058,11 @@ ${key.data.toString("base64")}
       }
     }
     return head.concat(event);
-  }
+  };
   var EventBlock = class extends Block {
     /**
      * @param {object} config
-     * @param {EventLink<T>} config.cid
+     * @param {API.EventLink<T>} config.cid
      * @param {Event} config.value
      * @param {Uint8Array} config.bytes
      * @param {string} config.prefix
@@ -19038,20 +19074,20 @@ ${key.data.toString("base64")}
     /**
      * @template T
      * @param {T} data
-     * @param {EventLink<T>[]} [parents]
+     * @param {API.EventLink<T>[]} [parents]
      */
     static create(data, parents) {
       return encodeEventBlock({ data, parents: parents ?? [] });
     }
   };
   var EventFetcher = class {
-    /** @param {import('./block').BlockFetcher} blocks */
+    /** @param {API.BlockFetcher} blocks */
     constructor(blocks) {
       this._blocks = blocks;
     }
     /**
-     * @param {EventLink<T>} link
-     * @returns {Promise<EventBlockView<T>>}
+     * @param {API.EventLink<T>} link
+     * @returns {Promise<API.EventBlockView<T>>}
      */
     async get(link2) {
       const block = await this._blocks.get(link2);
@@ -19060,15 +19096,15 @@ ${key.data.toString("base64")}
       return decodeEventBlock(block.bytes);
     }
   };
-  async function encodeEventBlock(value) {
+  var encodeEventBlock = async (value) => {
     const { cid, bytes } = await encode7({ value, codec: src_exports, hasher: sha256 });
     return new Block({ cid, value, bytes });
-  }
-  async function decodeEventBlock(bytes) {
+  };
+  var decodeEventBlock = async (bytes) => {
     const { cid, value } = await decode11({ bytes, codec: src_exports, hasher: sha256 });
     return new Block({ cid, value, bytes });
-  }
-  async function contains(events, a, b) {
+  };
+  var contains = async (events, a, b) => {
     if (a.toString() === b.toString())
       return true;
     const [{ value: aevent }, { value: bevent }] = await Promise.all([events.get(a), events.get(b)]);
@@ -19089,8 +19125,8 @@ ${key.data.toString("base64")}
       links3.push(...event.parents);
     }
     return false;
-  }
-  async function* vis(blocks, head, options = {}) {
+  };
+  var vis = async function* (blocks, head, options = {}) {
     const renderNodeLabel = options.renderNodeLabel ?? ((b) => shortLink(b.cid));
     const events = new EventFetcher(blocks);
     yield "digraph clock {";
@@ -19122,15 +19158,18 @@ ${key.data.toString("base64")}
       links3.push(...block.value.parents);
     }
     yield "}";
-  }
+  };
   var shortLink = (l) => `${String(l).slice(0, 4)}..${String(l).slice(-4)}`;
 
-  // ../../node_modules/.pnpm/@alanshaw+pail@0.3.4/node_modules/@alanshaw/pail/src/shard.js
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.0/node_modules/@web3-storage/pail/src/shard.js
+  var MaxKeyLength = 64;
+  var MaxShardSize = 512 * 1024;
+  var CID_TAG2 = new Token(Type.tag, 42);
   var ShardBlock = class extends Block {
     /**
      * @param {object} config
-     * @param {ShardLink} config.cid
-     * @param {Shard} config.value
+     * @param {API.ShardLink} config.cid
+     * @param {API.Shard} config.value
      * @param {Uint8Array} config.bytes
      * @param {string} config.prefix
      */
@@ -19138,94 +19177,105 @@ ${key.data.toString("base64")}
       super({ cid, value, bytes });
       this.prefix = prefix;
     }
-    static create() {
-      return encodeShardBlock([]);
+    /** @param {API.ShardOptions} [options] */
+    static create(options) {
+      return encodeBlock(create7(options));
     }
   };
+  var create7 = (options) => ({ entries: [], ...configure(options) });
+  var configure = (options) => ({
+    maxSize: options?.maxSize ?? MaxShardSize,
+    maxKeyLength: options?.maxKeyLength ?? MaxKeyLength
+  });
+  var withEntries = (entries3, options) => ({ ...create7(options), entries: entries3 });
   var decodeCache = /* @__PURE__ */ new WeakMap();
-  async function encodeShardBlock(value, prefix) {
+  var encodeBlock = async (value, prefix) => {
     const { cid, bytes } = await encode7({ value, codec: src_exports, hasher: sha256 });
     const block = new ShardBlock({ cid, value, bytes, prefix: prefix ?? "" });
     decodeCache.set(block.bytes, block);
     return block;
-  }
-  async function decodeShardBlock(bytes, prefix) {
+  };
+  var decodeBlock = async (bytes, prefix) => {
     const block = decodeCache.get(bytes);
     if (block)
       return block;
     const { cid, value } = await decode11({ bytes, codec: src_exports, hasher: sha256 });
-    if (!Array.isArray(value))
+    if (!isShard(value))
       throw new Error(`invalid shard: ${cid}`);
     return new ShardBlock({ cid, value, bytes, prefix: prefix ?? "" });
-  }
+  };
+  var isShard = (value) => value != null && typeof value === "object" && Array.isArray(value.entries) && typeof value.maxSize === "number" && typeof value.maxKeyLength === "number";
+  var isShardLink = (value) => isLink(value) && value.code === code;
   var ShardFetcher = class {
-    /** @param {import('./block').BlockFetcher} blocks */
+    /** @param {API.BlockFetcher} blocks */
     constructor(blocks) {
       this._blocks = blocks;
     }
     /**
-     * @param {ShardLink} link
+     * @param {API.ShardLink} link
      * @param {string} [prefix]
-     * @returns {Promise<ShardBlockView>}
+     * @returns {Promise<API.ShardBlockView>}
      */
     async get(link2, prefix = "") {
       const block = await this._blocks.get(link2);
       if (!block)
         throw new Error(`missing block: ${link2}`);
-      return decodeShardBlock(block.bytes, prefix);
-    }
-  };
-  function putEntry(target, entry) {
-    if (!target.length)
-      return [entry];
-    const shard = [];
-    for (const [i, [k, v]] of target.entries()) {
-      if (entry[0] === k) {
-        if (Array.isArray(entry[1])) {
-          if (Array.isArray(v) && v[1] != null && entry[1][1] == null) {
-            shard.push([k, [entry[1][0], v[1]]]);
+      return decodeBlock(block.bytes, prefix);
+    }
+  };
+  var putEntry = (target, newEntry) => {
+    const entries3 = [];
+    for (const [i, entry] of target.entries()) {
+      const [k, v] = entry;
+      if (newEntry[0] === k) {
+        if (Array.isArray(newEntry[1])) {
+          if (Array.isArray(v) && v[1] != null && newEntry[1][1] == null) {
+            entries3.push([k, [newEntry[1][0], v[1]]]);
           } else {
-            shard.push(entry);
+            entries3.push(newEntry);
           }
         } else {
-          const newEntry = Array.isArray(v) ? [k, [v[0], entry[1]]] : entry;
-          shard.push(newEntry);
+          if (Array.isArray(v)) {
+            entries3.push([k, [v[0], newEntry[1]]]);
+          } else {
+            entries3.push(newEntry);
+          }
         }
         for (let j = i + 1; j < target.length; j++) {
-          shard.push(target[j]);
+          entries3.push(target[j]);
         }
-        return shard;
+        return entries3;
       }
-      if (i === 0 && entry[0] < k) {
-        shard.push(entry);
+      if (i === 0 && newEntry[0] < k) {
+        entries3.push(newEntry);
         for (let j = i; j < target.length; j++) {
-          shard.push(target[j]);
+          entries3.push(target[j]);
         }
-        return shard;
+        return entries3;
       }
-      if (i > 0 && entry[0] > target[i - 1][0] && entry[0] < k) {
-        shard.push(entry);
+      if (i > 0 && newEntry[0] > target[i - 1][0] && newEntry[0] < k) {
+        entries3.push(newEntry);
         for (let j = i; j < target.length; j++) {
-          shard.push(target[j]);
+          entries3.push(target[j]);
         }
-        return shard;
+        return entries3;
       }
-      shard.push([k, v]);
+      entries3.push(entry);
     }
-    shard.push(entry);
-    return shard;
-  }
-  function findCommonPrefix(shard, skey) {
-    const startidx = shard.findIndex(([k]) => skey === k);
+    entries3.push(newEntry);
+    return entries3;
+  };
+  var findCommonPrefix = (entries3, skey) => {
+    const startidx = entries3.findIndex(([k]) => skey === k);
     if (startidx === -1)
       throw new Error(`key not found in shard: ${skey}`);
     let i = startidx;
     let pfx;
     while (true) {
-      pfx = shard[i][0].slice(0, -1);
+      pfx = entries3[i][0].slice(0, -1);
       if (pfx.length) {
         while (true) {
-          const matches = shard.filter((entry) => entry[0].startsWith(pfx));
+          const matches = entries3.filter((entry) => entry[0].startsWith(pfx));
           if (matches.length > 1)
             return { prefix: pfx, matches };
           pfx = pfx.slice(0, -1);
@@ -19234,19 +19284,50 @@ ${key.data.toString("base64")}
         }
       }
       i++;
-      if (i >= shard.length) {
+      if (i >= entries3.length) {
         i = 0;
       }
       if (i === startidx) {
         return;
       }
     }
-  }
+  };
+  var encodedLength = (shard) => {
+    let entriesLength = 0;
+    for (const entry of shard.entries) {
+      entriesLength += entryEncodedLength(entry);
+    }
+    const tokens = [
+      new Token(Type.map, 3),
+      new Token(Type.string, "entries"),
+      new Token(Type.array, shard.entries.length),
+      new Token(Type.string, "maxKeyLength"),
+      new Token(Type.uint, shard.maxKeyLength),
+      new Token(Type.string, "maxSize"),
+      new Token(Type.uint, shard.maxSize)
+    ];
+    return tokensToLength(tokens) + entriesLength;
+  };
+  var entryEncodedLength = (entry) => {
+    const tokens = [
+      new Token(Type.array, entry.length),
+      new Token(Type.string, entry[0])
+    ];
+    if (Array.isArray(entry[1])) {
+      tokens.push(new Token(Type.array, entry[1].length));
+      for (const link2 of entry[1]) {
+        tokens.push(CID_TAG2);
+        tokens.push(new Token(Type.bytes, { length: link2.byteLength + 1 }));
+      }
+    } else {
+      tokens.push(CID_TAG2);
+      tokens.push(new Token(Type.bytes, { length: entry[1].byteLength + 1 }));
+    }
+    return tokensToLength(tokens);
+  };
 
-  // ../../node_modules/.pnpm/@alanshaw+pail@0.3.4/node_modules/@alanshaw/pail/src/index.js
-  var MaxKeyLength = 64;
-  var MaxShardSize = 512 * 1024;
-  async function put(blocks, root2, key, value, options = {}) {
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.0/node_modules/@web3-storage/pail/src/index.js
+  var put = async (blocks, root2, key, value) => {
     const shards = new ShardFetcher(blocks);
     const rshard = await shards.get(root2);
     const path = await traverse(shards, rshard, key);
@@ -19254,31 +19335,40 @@ ${key.data.toString("base64")}
     const skey = key.slice(target.prefix.length);
     let entry = [skey, value];
     const additions = [];
-    if (skey.length > MaxKeyLength) {
-      const pfxskeys = Array.from(Array(Math.ceil(skey.length / MaxKeyLength)), (_, i) => {
-        const start = i * MaxKeyLength;
+    if (skey.length > target.value.maxKeyLength) {
+      const pfxskeys = Array.from(Array(Math.ceil(skey.length / target.value.maxKeyLength)), (_, i) => {
+        const start = i * target.value.maxKeyLength;
         return {
           prefix: target.prefix + skey.slice(0, start),
-          skey: skey.slice(start, start + MaxKeyLength)
+          skey: skey.slice(start, start + target.value.maxKeyLength)
         };
       });
-      let child2 = await encodeShardBlock([[pfxskeys[pfxskeys.length - 1].skey, value]], pfxskeys[pfxskeys.length - 1].prefix);
+      let child2 = await encodeBlock(
+        withEntries([[pfxskeys[pfxskeys.length - 1].skey, value]], target.value),
+        pfxskeys[pfxskeys.length - 1].prefix
+      );
       additions.push(child2);
       for (let i = pfxskeys.length - 2; i > 0; i--) {
-        child2 = await encodeShardBlock([[pfxskeys[i].skey, [child2.cid]]], pfxskeys[i].prefix);
+        child2 = await encodeBlock(
+          withEntries([[pfxskeys[i].skey, [child2.cid]]], target.value),
+          pfxskeys[i].prefix
+        );
         additions.push(child2);
       }
       entry = [pfxskeys[0].skey, [child2.cid]];
     }
-    let shard = putEntry(target.value, entry);
-    let child = await encodeShardBlock(shard, target.prefix);
-    if (child.bytes.length > (options.maxShardSize ?? MaxShardSize)) {
-      const common = findCommonPrefix(shard, entry[0]);
+    let shard = withEntries(putEntry(target.value.entries, entry), target.value);
+    let child = await encodeBlock(shard, target.prefix);
+    if (child.bytes.length > shard.maxSize) {
+      const common = findCommonPrefix(shard.entries, entry[0]);
       if (!common)
         throw new Error("shard limit reached");
       const { prefix, matches } = common;
-      const block = await encodeShardBlock(
-        matches.filter(([k]) => k !== prefix).map(([k, v]) => [k.slice(prefix.length), v]),
+      const block = await encodeBlock(
+        withEntries(
+          matches.filter(([k]) => k !== prefix).map(([k, v]) => [k.slice(prefix.length), v]),
+          shard
+        ),
         target.prefix + prefix
       );
       additions.push(block);
@@ -19292,9 +19382,9 @@ ${key.data.toString("base64")}
       } else {
         value2 = [block.cid];
       }
-      shard = shard.filter((e) => matches.every((m) => e[0] !== m[0]));
-      shard = putEntry(shard, [prefix, value2]);
-      child = await encodeShardBlock(shard, target.prefix);
+      shard.entries = shard.entries.filter((e) => matches.every((m) => e[0] !== m[0]));
+      shard = withEntries(putEntry(shard.entries, [prefix, value2]), shard);
+      child = await encodeBlock(shard, target.prefix);
     }
     if (child.cid.toString() === target.cid.toString()) {
       return { root: root2, additions: [], removals: [] };
@@ -19303,94 +19393,104 @@ ${key.data.toString("base64")}
     for (let i = path.length - 2; i >= 0; i--) {
       const parent = path[i];
       const key2 = child.prefix.slice(parent.prefix.length);
-      const value2 = parent.value.map((entry2) => {
-        const [k, v] = entry2;
-        if (k !== key2)
-          return entry2;
-        if (!Array.isArray(v))
-          throw new Error(`"${key2}" is not a shard link in: ${parent.cid}`);
-        return (
-          /** @type {import('./shard').ShardEntry} */
-          v[1] == null ? [k, [child.cid]] : [k, [child.cid, v[1]]]
-        );
-      });
-      child = await encodeShardBlock(value2, parent.prefix);
+      const value2 = withEntries(
+        parent.value.entries.map((entry2) => {
+          const [k, v] = entry2;
+          if (k !== key2)
+            return entry2;
+          if (!Array.isArray(v))
+            throw new Error(`"${key2}" is not a shard link in: ${parent.cid}`);
+          return (
+            /** @type {API.ShardEntry} */
+            v[1] == null ? [k, [child.cid]] : [k, [child.cid, v[1]]]
+          );
+        }),
+        parent.value
+      );
+      child = await encodeBlock(value2, parent.prefix);
       additions.push(child);
     }
     return { root: additions[additions.length - 1].cid, additions, removals: path };
-  }
-  async function get2(blocks, root2, key) {
+  };
+  var get2 = async (blocks, root2, key) => {
     const shards = new ShardFetcher(blocks);
     const rshard = await shards.get(root2);
     const path = await traverse(shards, rshard, key);
     const target = path[path.length - 1];
     const skey = key.slice(target.prefix.length);
-    const entry = target.value.find(([k]) => k === skey);
+    const entry = target.value.entries.find(([k]) => k === skey);
     if (!entry)
       return;
     return Array.isArray(entry[1]) ? entry[1][1] : entry[1];
-  }
-  async function del(blocks, root2, key) {
+  };
+  var del = async (blocks, root2, key) => {
     const shards = new ShardFetcher(blocks);
     const rshard = await shards.get(root2);
     const path = await traverse(shards, rshard, key);
     const target = path[path.length - 1];
     const skey = key.slice(target.prefix.length);
-    const entryidx = target.value.findIndex(([k]) => k === skey);
+    const entryidx = target.value.entries.findIndex(([k]) => k === skey);
     if (entryidx === -1)
       return { root: root2, additions: [], removals: [] };
-    const entry = target.value[entryidx];
-    if (Array.isArray(entry[1]) && entry[1][1] == null)
+    const entry = target.value.entries[entryidx];
+    if (Array.isArray(entry[1]) && entry[1][1] == null) {
       return { root: root2, additions: [], removals: [] };
+    }
     const additions = [];
     const removals = [...path];
-    let shard = [...target.value];
+    let shard = withEntries([...target.value.entries], target.value);
     if (Array.isArray(entry[1])) {
-      shard[entryidx] = [entry[0], [entry[1][0]]];
+      shard.entries[entryidx] = [entry[0], [entry[1][0]]];
     } else {
-      shard.splice(entryidx, 1);
-      while (!shard.length) {
+      shard.entries.splice(entryidx, 1);
+      while (!shard.entries.length) {
         const child2 = path[path.length - 1];
         const parent = path[path.length - 2];
         if (!parent)
           break;
         path.pop();
-        shard = parent.value.filter((e) => {
-          if (!Array.isArray(e[1]))
-            return true;
-          return e[1][0].toString() !== child2.cid.toString();
-        });
+        shard = withEntries(
+          parent.value.entries.filter((e) => {
+            if (!Array.isArray(e[1]))
+              return true;
+            return e[1][0].toString() !== child2.cid.toString();
+          }),
+          parent.value
+        );
       }
     }
-    let child = await encodeShardBlock(shard, path[path.length - 1].prefix);
+    let child = await encodeBlock(shard, path[path.length - 1].prefix);
     additions.push(child);
     for (let i = path.length - 2; i >= 0; i--) {
       const parent = path[i];
       const key2 = child.prefix.slice(parent.prefix.length);
-      const value = parent.value.map((entry2) => {
-        const [k, v] = entry2;
-        if (k !== key2)
-          return entry2;
-        if (!Array.isArray(v))
-          throw new Error(`"${key2}" is not a shard link in: ${parent.cid}`);
-        return (
-          /** @type {import('./shard').ShardEntry} */
-          v[1] == null ? [k, [child.cid]] : [k, [child.cid, v[1]]]
-        );
-      });
-      child = await encodeShardBlock(value, parent.prefix);
+      const value = withEntries(
+        parent.value.entries.map((entry2) => {
+          const [k, v] = entry2;
+          if (k !== key2)
+            return entry2;
+          if (!Array.isArray(v))
+            throw new Error(`"${key2}" is not a shard link in: ${parent.cid}`);
+          return (
+            /** @type {API.ShardEntry} */
+            v[1] == null ? [k, [child.cid]] : [k, [child.cid, v[1]]]
+          );
+        }),
+        parent.value
+      );
+      child = await encodeBlock(value, parent.prefix);
       additions.push(child);
     }
     return { root: additions[additions.length - 1].cid, additions, removals };
-  }
-  async function* entries(blocks, root2, options = {}) {
+  };
+  var entries = async function* (blocks, root2, options = {}) {
     const { prefix } = options;
     const shards = new ShardFetcher(blocks);
     const rshard = await shards.get(root2);
     yield* (
-      /** @returns {AsyncIterableIterator<import('./shard').ShardValueEntry>} */
+      /** @returns {AsyncIterableIterator<API.ShardValueEntry>} */
       async function* ents(shard) {
-        for (const entry of shard.value) {
+        for (const entry of shard.value.entries) {
           const key = shard.prefix + entry[0];
           if (Array.isArray(entry[1])) {
             if (entry[1][1]) {
@@ -19416,9 +19516,9 @@ ${key.data.toString("base64")}
         }
       }(rshard)
     );
-  }
-  async function traverse(shards, shard, key) {
-    for (const [k, v] of shard.value) {
+  };
+  var traverse = async (shards, shard, key) => {
+    for (const [k, v] of shard.value.entries) {
       if (key === k)
         return [shard];
       if (key.startsWith(k) && Array.isArray(v)) {
@@ -19427,16 +19527,204 @@ ${key.data.toString("base64")}
       }
     }
     return [shard];
-  }
+  };
+
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.0/node_modules/@web3-storage/pail/src/batch/shard.js
+  var create8 = (init2) => ({
+    base: init2?.base,
+    prefix: init2?.prefix ?? "",
+    entries: init2?.entries ?? [],
+    ...configure(init2)
+  });
+
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.0/node_modules/@web3-storage/pail/src/batch/index.js
+  var Batcher = class _Batcher {
+    #committed = false;
+    /**
+     * @param {object} init
+     * @param {API.BlockFetcher} init.blocks Block storage.
+     * @param {API.BatcherShardEntry[]} init.entries The entries in this shard.
+     * @param {string} init.prefix Key prefix.
+     * @param {number} init.maxSize
+     * @param {number} init.maxKeyLength
+     * @param {API.ShardBlockView} init.base Original shard this batcher is based on.
+     */
+    constructor({ blocks, entries: entries3, prefix, maxSize, maxKeyLength, base: base4 }) {
+      this.blocks = blocks;
+      this.prefix = prefix;
+      this.entries = entries3;
+      this.base = base4;
+      this.maxSize = maxSize;
+      this.maxKeyLength = maxKeyLength;
+    }
+    /**
+     * @param {string} key The key of the value to put.
+     * @param {API.UnknownLink} value The value to put.
+     * @returns {Promise<void>}
+     */
+    async put(key, value) {
+      if (this.#committed)
+        throw new BatchCommittedError();
+      return put2(this.blocks, this, key, value);
+    }
+    async commit() {
+      if (this.#committed)
+        throw new BatchCommittedError();
+      this.#committed = true;
+      return commit(this);
+    }
+    /**
+     * @param {object} init
+     * @param {API.BlockFetcher} init.blocks Block storage.
+     * @param {API.ShardLink} init.link CID of the shard block.
+     * @param {string} init.prefix
+     */
+    static async create({ blocks, link: link2, prefix }) {
+      const shards = new ShardFetcher(blocks);
+      const base4 = await shards.get(link2);
+      return new _Batcher({ blocks, entries: base4.value.entries, prefix, base: base4, ...configure(base4.value) });
+    }
+  };
+  var put2 = async (blocks, shard, key, value) => {
+    const shards = new ShardFetcher(blocks);
+    const dest = await traverse2(shards, key, shard);
+    if (dest.shard !== shard) {
+      shard = dest.shard;
+      key = dest.key;
+    }
+    let entry = [key, value];
+    let batcher;
+    if (key.length > shard.maxKeyLength) {
+      const pfxskeys = Array.from(Array(Math.ceil(key.length / shard.maxKeyLength)), (_, i) => {
+        const start = i * shard.maxKeyLength;
+        return {
+          prefix: shard.prefix + key.slice(0, start),
+          key: key.slice(start, start + shard.maxKeyLength)
+        };
+      });
+      entry = [pfxskeys[pfxskeys.length - 1].key, value];
+      batcher = create8({
+        entries: [entry],
+        prefix: pfxskeys[pfxskeys.length - 1].prefix,
+        ...configure(shard)
+      });
+      for (let i = pfxskeys.length - 2; i > 0; i--) {
+        entry = [pfxskeys[i].key, [batcher]];
+        batcher = create8({
+          entries: [entry],
+          prefix: pfxskeys[i].prefix,
+          ...configure(shard)
+        });
+      }
+      entry = [pfxskeys[0].key, [batcher]];
+    }
+    shard.entries = putEntry(asShardEntries(shard.entries), asShardEntry(entry));
+    const size = encodedLength(withEntries(asShardEntries(shard.entries), shard));
+    if (size > shard.maxSize) {
+      const common = findCommonPrefix(
+        asShardEntries(shard.entries),
+        entry[0]
+      );
+      if (!common)
+        throw new Error("shard limit reached");
+      const { prefix } = common;
+      const matches = common.matches;
+      const entries3 = matches.filter((m) => m[0] !== prefix).map((m) => {
+        m = [...m];
+        m[0] = m[0].slice(prefix.length);
+        return m;
+      });
+      const batcher2 = create8({
+        entries: entries3,
+        prefix: shard.prefix + prefix,
+        ...configure(shard)
+      });
+      let value2;
+      const pfxmatch = matches.find((m) => m[0] === prefix);
+      if (pfxmatch) {
+        if (Array.isArray(pfxmatch[1])) {
+          throw new Error(`expected "${prefix}" to be a shard value but found a shard link`);
+        }
+        value2 = [batcher2, pfxmatch[1]];
+      } else {
+        value2 = [batcher2];
+      }
+      shard.entries = putEntry(
+        asShardEntries(shard.entries.filter((e) => matches.every((m) => e[0] !== m[0]))),
+        asShardEntry([prefix, value2])
+      );
+    }
+  };
+  var traverse2 = async (shards, key, shard) => {
+    for (const e of shard.entries) {
+      const [k, v] = e;
+      if (key <= k)
+        break;
+      if (key.startsWith(k) && Array.isArray(v)) {
+        if (isShardLink(v[0])) {
+          const blk = await shards.get(v[0], shard.prefix + k);
+          v[0] = create8({ base: blk, prefix: blk.prefix, ...blk.value });
+        }
+        return traverse2(shards, key.slice(k.length), v[0]);
+      }
+    }
+    return { shard, key };
+  };
+  var commit = async (shard) => {
+    const additions = [];
+    const removals = [];
+    const entries3 = [];
+    for (const entry of shard.entries) {
+      if (Array.isArray(entry[1]) && !isShardLink(entry[1][0])) {
+        const result = await commit(entry[1][0]);
+        entries3.push([
+          entry[0],
+          entry[1][1] == null ? [result.root] : [result.root, entry[1][1]]
+        ]);
+        additions.push(...result.additions);
+        removals.push(...result.removals);
+      } else {
+        entries3.push(asShardEntry(entry));
+      }
+    }
+    const block = await encodeBlock(withEntries(entries3, shard), shard.prefix);
+    additions.push(block);
+    if (shard.base && shard.base.cid.toString() === block.cid.toString()) {
+      return { root: block.cid, additions: [], removals: [] };
+    }
+    if (shard.base)
+      removals.push(shard.base);
+    return { root: block.cid, additions, removals };
+  };
+  var asShardEntries = (entries3) => (
+    /** @type {API.ShardEntry[]} */
+    entries3
+  );
+  var asShardEntry = (entry) => (
+    /** @type {API.ShardEntry} */
+    entry
+  );
+  var create9 = (blocks, root2) => Batcher.create({ blocks, link: root2, prefix: "" });
+  var BatchCommittedError = class _BatchCommittedError extends Error {
+    /**
+     * @param {string} [message]
+     * @param {ErrorOptions} [options]
+     */
+    constructor(message2, options) {
+      super(message2 ?? "batch already committed", options);
+      this.code = _BatchCommittedError.code;
+    }
+    static code = "ERR_BATCH_COMMITTED";
+  };
 
-  // ../../node_modules/.pnpm/@alanshaw+pail@0.3.4/node_modules/@alanshaw/pail/src/crdt.js
-  async function put2(blocks, head, key, value, options) {
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.0/node_modules/@web3-storage/pail/src/crdt/index.js
+  var put3 = async (blocks, head, key, value) => {
     const mblocks = new MemoryBlockstore();
     blocks = new MultiBlockFetcher(mblocks, blocks);
     if (!head.length) {
       const shard = await ShardBlock.create();
       mblocks.putSync(shard.cid, shard.bytes);
-      const result2 = await put(blocks, shard.cid, key, value, options);
+      const result2 = await put(blocks, shard.cid, key, value);
       const data2 = { type: "put", root: result2.root, key, value };
       const event2 = await EventBlock.create(data2, head);
       head = await advance(blocks, head, event2.cid);
@@ -19458,10 +19746,22 @@ ${key.data.toString("base64")}
     const additions = /* @__PURE__ */ new Map();
     const removals = /* @__PURE__ */ new Map();
     for (const { value: event2 } of sorted) {
-      if (!["put", "del"].includes(event2.data.type)) {
-        throw new Error(`unknown event type: ${event2.data.type}`);
+      let result2;
+      if (event2.data.type === "put") {
+        result2 = await put(blocks, root2, event2.data.key, event2.data.value);
+      } else if (event2.data.type === "del") {
+        result2 = await del(blocks, root2, event2.data.key);
+      } else if (event2.data.type === "batch") {
+        const batch2 = await create9(blocks, root2);
+        for (const op of event2.data.ops) {
+          if (op.type !== "put")
+            throw new Error(`unsupported batch operation: ${op.type}`);
+          await batch2.put(op.key, op.value);
+        }
+        result2 = await batch2.commit();
+      } else {
+        throw new Error(`unknown operation: ${event2.data.type}`);
       }
-      const result2 = event2.data.type === "put" ? await put(blocks, root2, event2.data.key, event2.data.value) : await del(blocks, root2, event2.data.key);
       root2 = result2.root;
       for (const a of result2.additions) {
         mblocks.putSync(a.cid, a.bytes);
@@ -19471,7 +19771,7 @@ ${key.data.toString("base64")}
         removals.set(r.cid.toString(), r);
       }
     }
-    const result = await put(blocks, root2, key, value, options);
+    const result = await put(blocks, root2, key, value);
     if (result.root.toString() === root2.toString()) {
       return { root: root2, additions: [], removals: [], head };
     }
@@ -19499,8 +19799,8 @@ ${key.data.toString("base64")}
       head,
       event
     };
-  }
-  async function root(blocks, head) {
+  };
+  var root = async (blocks, head) => {
     if (!head.length)
       throw new Error("cannot determine root of headless clock");
     const mblocks = new MemoryBlockstore();
@@ -19520,10 +19820,22 @@ ${key.data.toString("base64")}
     const additions = /* @__PURE__ */ new Map();
     const removals = /* @__PURE__ */ new Map();
     for (const { value: event } of sorted) {
-      if (!["put", "del"].includes(event.data.type)) {
-        throw new Error(`unknown event type: ${event.data.type}`);
+      let result;
+      if (event.data.type === "put") {
+        result = await put(blocks, root2, event.data.key, event.data.value);
+      } else if (event.data.type === "del") {
+        result = await del(blocks, root2, event.data.key);
+      } else if (event.data.type === "batch") {
+        const batch2 = await create9(blocks, root2);
+        for (const op of event.data.ops) {
+          if (op.type !== "put")
+            throw new Error(`unsupported batch operation: ${op.type}`);
+          await batch2.put(op.key, op.value);
+        }
+        result = await batch2.commit();
+      } else {
+        throw new Error(`unknown operation: ${event.data.type}`);
       }
-      const result = event.data.type === "put" ? await put(blocks, root2, event.data.key, event.data.value) : await del(blocks, root2, event.data.key);
       root2 = result.root;
       for (const a of result.additions) {
         mblocks.putSync(a.cid, a.bytes);
@@ -19544,8 +19856,8 @@ ${key.data.toString("base64")}
       additions: [...additions.values()],
       removals: [...removals.values()]
     };
-  }
-  async function get3(blocks, head, key) {
+  };
+  var get3 = async (blocks, head, key) => {
     if (!head.length)
       return;
     const result = await root(blocks, head);
@@ -19553,8 +19865,8 @@ ${key.data.toString("base64")}
       blocks = new MultiBlockFetcher(new MemoryBlockstore(result.additions), blocks);
     }
     return get2(blocks, result.root, key);
-  }
-  async function* entries2(blocks, head, options) {
+  };
+  var entries2 = async function* (blocks, head, options) {
     if (!head.length)
       return;
     const result = await root(blocks, head);
@@ -19562,8 +19874,8 @@ ${key.data.toString("base64")}
       blocks = new MultiBlockFetcher(new MemoryBlockstore(result.additions), blocks);
     }
     yield* entries(blocks, result.root, options);
-  }
-  async function findCommonAncestor(events, children) {
+  };
+  var findCommonAncestor = async (events, children) => {
     if (!children.length)
       return;
     const candidates = children.map((c) => [c]);
@@ -19582,14 +19894,14 @@ ${key.data.toString("base64")}
       if (!changed)
         return;
     }
-  }
-  async function findAncestorCandidate(events, root2) {
+  };
+  var findAncestorCandidate = async (events, root2) => {
     const { value: event } = await events.get(root2);
     if (!event.parents.length)
       return root2;
     return event.parents.length === 1 ? event.parents[0] : findCommonAncestor(events, event.parents);
-  }
-  function findCommonString(arrays) {
+  };
+  var findCommonString = (arrays) => {
     arrays = arrays.map((a) => [...a]);
     for (const arr of arrays) {
       for (const item of arr) {
@@ -19605,9 +19917,9 @@ ${key.data.toString("base64")}
           return item;
       }
     }
-  }
-  async function findSortedEvents(events, head, tail) {
-    if (head.length === 1 && String(head[0]) === String(tail)) {
+  };
+  var findSortedEvents = async (events, head, tail) => {
+    if (head.length === 1 && head[0].toString() === tail.toString()) {
       return [];
     }
     const weights = /* @__PURE__ */ new Map();
@@ -19632,8 +19944,8 @@ ${key.data.toString("base64")}
       }
     }
     return Array.from(buckets).sort((a, b) => b[0] - a[0]).flatMap(([, es]) => es.sort((a, b) => String(a.cid) < String(b.cid) ? -1 : 1));
-  }
-  async function findEvents(events, start, end, depth = 0) {
+  };
+  var findEvents = async (events, start, end, depth = 0) => {
     const event = await events.get(start);
     const acc = [{ event, depth }];
     const { parents } = event.value;
@@ -19641,7 +19953,128 @@ ${key.data.toString("base64")}
       return acc;
     const rest = await Promise.all(parents.map((p) => findEvents(events, p, end, depth + 1)));
     return acc.concat(...rest);
-  }
+  };
+
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.0/node_modules/@web3-storage/pail/src/crdt/batch/index.js
+  var Batcher2 = class _Batcher {
+    #committed = false;
+    /**
+     * @param {object} init
+     * @param {API.BlockFetcher} init.blocks Block storage.
+     * @param {API.EventLink<API.Operation>[]} init.head Merkle clock head.
+     * @param {API.BatcherShardEntry[]} init.entries The entries in this shard.
+     * @param {string} init.prefix Key prefix.
+     * @param {number} init.maxSize
+     * @param {number} init.maxKeyLength
+     * @param {API.ShardBlockView} init.base Original shard this batcher is based on.
+     * @param {API.ShardBlockView[]} init.additions Additions to include in the committed batch.
+     * @param {API.ShardBlockView[]} init.removals Removals to include in the committed batch.
+     */
+    constructor({ blocks, head, entries: entries3, prefix, maxSize, maxKeyLength, base: base4, additions, removals }) {
+      this.blocks = blocks;
+      this.head = head;
+      this.prefix = prefix;
+      this.entries = entries3;
+      this.base = base4;
+      this.maxSize = maxSize;
+      this.maxKeyLength = maxKeyLength;
+      this.additions = additions;
+      this.removals = removals;
+      this.ops = [];
+    }
+    /**
+     * @param {string} key The key of the value to put.
+     * @param {API.UnknownLink} value The value to put.
+     * @returns {Promise<void>}
+     */
+    async put(key, value) {
+      if (this.#committed)
+        throw new BatchCommittedError();
+      await put2(this.blocks, this, key, value);
+      this.ops.push({ type: "put", key, value });
+    }
+    async commit() {
+      if (this.#committed)
+        throw new BatchCommittedError();
+      this.#committed = true;
+      const res = await commit(this);
+      const data = { type: "batch", ops: this.ops, root: res.root };
+      const event = await EventBlock.create(data, this.head);
+      const mblocks = new MemoryBlockstore();
+      const blocks = new MultiBlockFetcher(mblocks, this.blocks);
+      mblocks.putSync(event.cid, event.bytes);
+      const head = await advance(blocks, this.head, event.cid);
+      const additions = /* @__PURE__ */ new Map();
+      const removals = /* @__PURE__ */ new Map();
+      for (const a of this.additions) {
+        additions.set(a.cid.toString(), a);
+      }
+      for (const r of this.removals) {
+        removals.set(r.cid.toString(), r);
+      }
+      for (const a of res.additions) {
+        if (removals.has(a.cid.toString())) {
+          removals.delete(a.cid.toString());
+        }
+        additions.set(a.cid.toString(), a);
+      }
+      for (const r of res.removals) {
+        if (additions.has(r.cid.toString())) {
+          additions.delete(r.cid.toString());
+        } else {
+          removals.set(r.cid.toString(), r);
+        }
+      }
+      return {
+        head,
+        event,
+        root: res.root,
+        additions: [...additions.values()],
+        removals: [...removals.values()]
+      };
+    }
+    /**
+     * @param {object} init
+     * @param {API.BlockFetcher} init.blocks Block storage.
+     * @param {API.EventLink<API.Operation>[]} init.head Merkle clock head.
+     * @param {string} init.prefix
+     */
+    static async create({ blocks, head, prefix }) {
+      const mblocks = new MemoryBlockstore();
+      blocks = new MultiBlockFetcher(mblocks, blocks);
+      if (!head.length) {
+        const base5 = await ShardBlock.create();
+        mblocks.putSync(base5.cid, base5.bytes);
+        return new _Batcher({
+          blocks,
+          head,
+          entries: [],
+          prefix,
+          base: base5,
+          additions: [base5],
+          removals: [],
+          ...configure(base5.value)
+        });
+      }
+      const { root: root2, additions, removals } = await root(blocks, head);
+      for (const a of additions) {
+        mblocks.putSync(a.cid, a.bytes);
+      }
+      const shards = new ShardFetcher(blocks);
+      const base4 = await shards.get(root2);
+      return new _Batcher({
+        blocks,
+        head,
+        entries: base4.value.entries,
+        prefix,
+        base: base4,
+        additions,
+        removals,
+        ...configure(base4.value)
+      });
+    }
+  };
+  var create10 = (blocks, head) => Batcher2.create({ blocks, head, prefix: "" });
 
   // ../../node_modules/.pnpm/@ipld+unixfs@2.1.2/node_modules/@ipld/unixfs/src/codec.js
   var codec_exports = {};
@@ -22449,7 +22882,7 @@ ${key.data.toString("base64")}
   };
 
   // ../../node_modules/.pnpm/multiformats@11.0.2/node_modules/multiformats/src/hashes/digest.js
-  var create7 = (code8, digest3) => {
+  var create11 = (code8, digest3) => {
     const size = digest3.byteLength;
     const sizeOffset = encodingLength3(code8);
     const digestOffset = sizeOffset + encodingLength3(size);
@@ -22518,7 +22951,7 @@ ${key.data.toString("base64")}
     digest(input) {
       if (input instanceof Uint8Array) {
         const result = this.encode(input);
-        return result instanceof Uint8Array ? create7(this.code, result) : result.then((digest3) => create7(this.code, digest3));
+        return result instanceof Uint8Array ? create11(this.code, result) : result.then((digest3) => create11(this.code, digest3));
       } else {
         throw Error("Unknown type, must be binary type");
       }
@@ -23059,7 +23492,7 @@ ${key.data.toString("base64")}
       switch (this.version) {
         case 0: {
           const { code: code8, digest: digest3 } = this.multihash;
-          const multihash = create7(code8, digest3);
+          const multihash = create11(code8, digest3);
           return (
             /** @type {CID<Data, Format, Alg, 1>} */
             _CID.createV1(this.code, multihash)
@@ -23590,7 +24023,7 @@ ${key.data.toString("base64")}
     hasher: sha2562,
     linker: { createLink: CID3.createV1 }
   });
-  var configure = (config2) => ({
+  var configure2 = (config2) => ({
     ...defaults2(),
     ...config2
   });
@@ -23599,7 +24032,7 @@ ${key.data.toString("base64")}
     name: name3,
     encode: encodeFileChunk
   };
-  var create8 = ({ writer, metadata = {}, settings: settings2 = defaults2() }) => new FileWriterView(init(writer, metadata, configure(settings2)));
+  var create12 = ({ writer, metadata = {}, settings: settings2 = defaults2() }) => new FileWriterView(init(writer, metadata, configure2(settings2)));
   var write4 = async (view, bytes) => {
     await perform(view, send({ type: "write", bytes }));
     return view;
@@ -23658,7 +24091,7 @@ ${key.data.toString("base64")}
 
   // ../../node_modules/.pnpm/@ipld+unixfs@2.1.2/node_modules/@ipld/unixfs/src/directory.js
   var defaults3 = defaults2;
-  var create9 = ({ writer, settings: settings2 = defaults3(), metadata = {} }) => new DirectoryWriter({
+  var create13 = ({ writer, settings: settings2 = defaults3(), metadata = {} }) => new DirectoryWriter({
     writer,
     metadata,
     settings: settings2,
@@ -23859,7 +24292,7 @@ ${key.data.toString("base64")}
     /** @type {Uint8Array} */
     murmur364.encode(bytes)
   );
-  var configure4 = ({ bitWidth: bitWidth2 = 8, hash = hash64 }) => {
+  var configure5 = ({ bitWidth: bitWidth2 = 8, hash = hash64 }) => {
     const hashSize = hash(new Uint8Array()).byteLength;
     const options = { bitWidth: bitWidth2, hash, hashSize };
     const at = (path, depth) => read4(path, depth, options);
@@ -23896,7 +24329,7 @@ ${key.data.toString("base64")}
   var bitWidth = 8;
   var config = {
     bitWidth,
-    Path: configure4({ bitWidth })
+    Path: configure5({ bitWidth })
   };
 
   // ../../node_modules/.pnpm/@ipld+unixfs@2.1.2/node_modules/@ipld/unixfs/src/lib.js
@@ -23920,14 +24353,14 @@ ${key.data.toString("base64")}
      */
     constructor({ writer, settings: settings2 }) {
       this.writer = writer;
-      this.settings = configure(settings2);
+      this.settings = configure2(settings2);
     }
     /**
      * @template [L=unknown]
      * @param {API.WriterOptions<L|Layout>} config
      */
     createFileWriter({ settings: settings2 = this.settings, metadata } = {}) {
-      return create8({
+      return create12({
         writer: this.writer,
         settings: settings2,
         metadata
@@ -23938,7 +24371,7 @@ ${key.data.toString("base64")}
      * @param {API.WriterOptions<L|Layout>} config
      */
     createDirectoryWriter({ settings: settings2 = this.settings, metadata } = {}) {
-      return create9({
+      return create13({
         writer: this.writer,
         settings: settings2,
         metadata
@@ -27208,7 +27641,7 @@ ${key.data.toString("base64")}
   var import_err_code7 = __toESM(require_err_code(), 1);
 
   // ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
-  var import_index6 = __toESM(require_eventemitter3(), 1);
+  var import_index5 = __toESM(require_eventemitter3(), 1);
 
   // ../../node_modules/.pnpm/p-timeout@6.1.2/node_modules/p-timeout/index.js
   var TimeoutError = class extends Error {
@@ -27343,7 +27776,7 @@ ${key.data.toString("base64")}
   };
 
   // ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/index.js
-  var PQueue = class extends import_index6.default {
+  var PQueue = class extends import_index5.default {
     #carryoverConcurrencyCount;
     #isIntervalIgnored;
     #intervalCount = 0;
@@ -27985,7 +28418,7 @@ ${key.data.toString("base64")}
 
   // src/files.ts
   var queuingStrategy = withCapacity();
-  var settings = configure({
+  var settings = configure2({
     fileChunkEncoder: raw_exports,
     smallFileEncoder: raw_exports,
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
@@ -28034,7 +28467,7 @@ ${key.data.toString("base64")}
       this.#file = file;
     }
     async finalize(writer) {
-      const unixfsFileWriter = create8(writer);
+      const unixfsFileWriter = create12(writer);
       await this.#file.stream().pipeTo(
         new WritableStream({
           async write(chunk) {
@@ -28047,30 +28480,43 @@ ${key.data.toString("base64")}
   };
 
   // src/crdt-helpers.ts
-  async function applyBulkUpdateToCrdt(tblocks, head, updates, options) {
-    let result;
-    for (const update2 of updates) {
-      const link2 = await writeDocContent(tblocks, update2);
-      result = await put2(tblocks, head, update2.key, link2, options);
-      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()}`
-          );
-          result.head = head;
-        }
+  function time(tag2) {
+  }
+  function timeEnd(tag2) {
+  }
+  async function applyBulkUpdateToCrdt(tblocks, head, updates) {
+    let result = null;
+    if (updates.length > 1) {
+      const batch2 = await create10(tblocks, head);
+      for (const update2 of updates) {
+        const link2 = await writeDocContent(tblocks, update2);
+        await batch2.put(update2.key, link2);
       }
-      if (result.event) {
-        for (const { cid, bytes } of [...result.additions, result.event]) {
-          tblocks.putSync(cid, bytes);
+      result = await batch2.commit();
+    } else {
+      for (const update2 of updates) {
+        const link2 = await writeDocContent(tblocks, update2);
+        result = await put3(tblocks, head, update2.key, link2);
+        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()}`
+            );
+          }
         }
-        head = result.head;
       }
     }
-    return { head };
+    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, update2) {
     let value;
@@ -28208,37 +28654,33 @@ ${key.data.toString("base64")}
       const { value: event } = await eventsFetcher.get(link2);
       if (!event)
         continue;
-      const { key, value } = event.data;
-      if (keys.has(key)) {
-        if (event.parents) {
-          updates = await gatherUpdates(
-            blocks,
-            eventsFetcher,
-            event.parents,
-            since,
-            updates,
-            keys,
-            didLinks,
-            limit
-          );
-        }
-      } else {
-        keys.add(key);
-        const docValue = await getValueFromLink(blocks, value);
-        updates.push({ key, value: docValue.doc, del: docValue.del, clock: link2 });
-        limit--;
-        if (event.parents) {
-          updates = await gatherUpdates(
-            blocks,
-            eventsFetcher,
-            event.parents,
-            since,
-            updates,
-            keys,
-            didLinks,
-            limit
-          );
-        }
+      const { type: type2 } = event.data;
+      let ops = [];
+      if (type2 === "batch") {
+        ops = event.data.ops;
+      } else if (type2 === "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: link2 });
+          limit--;
+          keys.add(key);
+        }
+      }
+      if (event.parents) {
+        updates = await gatherUpdates(
+          blocks,
+          eventsFetcher,
+          event.parents,
+          since,
+          updates,
+          keys,
+          didLinks,
+          limit
+        );
       }
     }
     return updates;
@@ -28261,25 +28703,32 @@ ${key.data.toString("base64")}
       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());
     }
-    for await (const entry of getAllEntries(blockLog, head)) {
-    }
-    for await (const [, link2] of entries2(blockLog, head)) {
-      const bl = await blockLog.get(link2);
-      if (!bl)
-        throw new Error("Missing entry block: " + link2.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) {
@@ -28404,7 +28853,7 @@ ${key.data.toString("base64")}
     });
     return getNode;
   };
-  var create12 = ({ get: get7, cache: cache4, chunker: chunker3, list, codec, hasher, sorted, compare: compare5, ...opts }) => {
+  var create16 = ({ get: get7, cache: cache4, chunker: chunker3, list, codec, hasher, sorted, compare: compare5, ...opts }) => {
     if (!sorted)
       list = list.sort(({ key: a }, { key: b }) => compare5(a, b));
     const getNode = createGetNode2(get7, cache4, chunker3, codec, hasher, compare5, opts);
@@ -28585,12 +29034,12 @@ ${key.data.toString("base64")}
     ...classes2,
     compare: compare3
   };
-  var create13 = (opts) => {
+  var create17 = (opts) => {
     opts = {
       ...defaults4,
       ...opts
     };
-    return create12(opts);
+    return create16(opts);
   };
   var load3 = (opts) => {
     opts = {
@@ -28666,7 +29115,7 @@ ${key.data.toString("base64")}
       if (!inIndex.cid) {
         let returnRootBlock = null;
         let returnNode = null;
-        for await (const node of await create13({ get: makeProllyGetBlock(tblocks), list: indexEntries, ...opts })) {
+        for await (const node of await create17({ get: makeProllyGetBlock(tblocks), list: indexEntries, ...opts })) {
           const block = await node.block;
           await tblocks.put(block.cid, block.bytes);
           returnRootBlock = block;
@@ -29140,12 +29589,12 @@ ${key.data.toString("base64")}
         }
       });
     }
-    async bulk(updates, options) {
+    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, options);
+          const { head } = await applyBulkUpdateToCrdt(blocks, this.clock.head, updates);
           updates = updates.map(({ key, value, del: del2, clock }) => {
             readFiles(this.blockstore, { doc: value });
             return { key, value, del: del2, clock };