@web3-storage/pail 0.6.2 → 0.6.3-rc.1

package/dist/src/batch/api.d.ts

@@ -20,6 +20,11 @@ export interface Batcher {
      * overwritten.
      */
     put: (key: string, value: UnknownLink) => Promise<void>;
+    /**
+     * Delete the value for the given key. If the key is not found no operation
+     * occurs.
+     */
+    del: (key: string) => Promise<void>;
     /**
      * Encode all altered shards in the batch and return the new root CID and
      * difference blocks.

package/dist/src/batch/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/batch/api.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,SAAS,EACT,SAAS,EACT,UAAU,EACV,oBAAoB,EACpB,mBAAmB,EACnB,2BAA2B,EAC3B,WAAW,EACX,YAAY,EACZ,cAAc,EACd,YAAY,EACb,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,WAAW,EACX,SAAS,EACT,SAAS,EACT,UAAU,EACV,oBAAoB,EACpB,mBAAmB,EACnB,2BAA2B,EAC3B,WAAW,EACX,YAAY,EACZ,cAAc,EACd,YAAY,EACb,CAAA;AAED,MAAM,WAAW,YAAa,SAAQ,WAAW;IAC/C,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,OAAO,EAAE,iBAAiB,EAAE,CAAA;CAC7B;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,OAAO,CAAC,EAAE,iBAAiB,EAAE,CAAA;CAC9B;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM;IACX,KAAK,EAAE,oBAAoB,GAAG,mBAAmB,GAAG,2BAA2B,GAAG,oBAAoB,GAAG,4BAA4B;CACtI,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,CAAC,YAAY,CAAC,CAAA;AAEjD,MAAM,MAAM,4BAA4B,GAAG,CAAC,YAAY,EAAE,WAAW,CAAC,CAAA;AAEtE,MAAM,WAAW,OAAO;IACtB;;;OAGG;IACH,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACvD;;;OAGG;IACH,MAAM,EAAE,MAAM,OAAO,CAAC;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,GAAG,SAAS,CAAC,CAAA;CACvD"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/batch/api.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,SAAS,EACT,SAAS,EACT,UAAU,EACV,oBAAoB,EACpB,mBAAmB,EACnB,2BAA2B,EAC3B,WAAW,EACX,YAAY,EACZ,cAAc,EACd,YAAY,EACb,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,WAAW,EACX,SAAS,EACT,SAAS,EACT,UAAU,EACV,oBAAoB,EACpB,mBAAmB,EACnB,2BAA2B,EAC3B,WAAW,EACX,YAAY,EACZ,cAAc,EACd,YAAY,EACb,CAAA;AAED,MAAM,WAAW,YAAa,SAAQ,WAAW;IAC/C,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,OAAO,EAAE,iBAAiB,EAAE,CAAA;CAC7B;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,OAAO,CAAC,EAAE,iBAAiB,EAAE,CAAA;CAC9B;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM;IACX,KAAK,EAAE,oBAAoB,GAAG,mBAAmB,GAAG,2BAA2B,GAAG,oBAAoB,GAAG,4BAA4B;CACtI,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,CAAC,YAAY,CAAC,CAAA;AAEjD,MAAM,MAAM,4BAA4B,GAAG,CAAC,YAAY,EAAE,WAAW,CAAC,CAAA;AAEtE,MAAM,WAAW,OAAO;IACtB;;;OAGG;IACH,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACvD;;;OAGG;IACH,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC;;;OAGG;IACH,MAAM,EAAE,MAAM,OAAO,CAAC;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,GAAG,SAAS,CAAC,CAAA;CACvD"}

package/dist/src/batch/index.d.ts

@@ -1,4 +1,5 @@
 export function put(blocks: API.BlockFetcher, shard: API.BatcherShard, key: string, value: API.UnknownLink): Promise<void>;
+export function del(blocks: API.BlockFetcher, shard: API.BatcherShard, key: string): Promise<void>;
 export function traverse(shards: ShardFetcher, shard: API.BatcherShard, key: string): Promise<{
     shard: API.BatcherShard;
     key: string;

package/dist/src/batch/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/batch/index.js"],"names":[],"mappings":"AAiEO,4BANI,GAAG,CAAC,YAAY,SAChB,GAAG,CAAC,YAAY,OAChB,MAAM,SACN,GAAG,CAAC,WAAW,GACb,OAAO,CAAC,IAAI,CAAC,CAsGzB;AAWM,iCALI,YAAY,SACZ,GAAG,CAAC,YAAY,OAChB,MAAM,GACJ,OAAO,CAAC;IAAE,KAAK,EAAE,GAAG,CAAC,YAAY,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAiB7D;AAQM,8BAFI,GAAG,CAAC,YAAY;;;;GAkC1B;AAaM,+BAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,GACX,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAE6C;AAE9E;IAUE,oBAAmC;IATnC;;;OAGG;IACH,sBAHW,MAAM,YACN,YAAY,EAKtB;IADC,aAAoC;CAIvC;qBAhQoB,UAAU;6BACgB,aAAa"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/batch/index.js"],"names":[],"mappings":"AA0EO,4BANI,GAAG,CAAC,YAAY,SAChB,GAAG,CAAC,YAAY,OAChB,MAAM,SACN,GAAG,CAAC,WAAW,GACb,OAAO,CAAC,IAAI,CAAC,CAsGzB;AAQM,4BALI,GAAG,CAAC,YAAY,SAChB,GAAG,CAAC,YAAY,OAChB,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAmBzB;AAWM,iCALI,YAAY,SACZ,GAAG,CAAC,YAAY,OAChB,MAAM,GACJ,OAAO,CAAC;IAAE,KAAK,EAAE,GAAG,CAAC,YAAY,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAiB7D;AAQM,8BAFI,GAAG,CAAC,YAAY;;;;GAkC1B;AAaM,+BAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,GACX,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAE6C;AAE9E;IAUE,oBAAmC;IATnC;;;OAGG;IACH,sBAHW,MAAM,YACN,YAAY,EAKtB;IADC,aAAoC;CAIvC;qBAlSoB,UAAU;6BACgB,aAAa"}

package/dist/src/batch/index.js

@@ -35,6 +35,15 @@ class Batcher {
             throw new BatchCommittedError();
         return put(this.blocks, this, key, value);
     }
+    /**
+     * @param {string} key The key of the value to delete.
+     * @returns {Promise<void>}
+     */
+    async del(key) {
+        if (this.#committed)
+            throw new BatchCommittedError();
+        return del(this.blocks, this, key);
+    }
     async commit() {
         if (this.#committed)
             throw new BatchCommittedError();
@@ -156,6 +165,31 @@ export const put = async (blocks, shard, key, value) => {
     }
     shard.entries = Shard.putEntry(asShardEntries(targetEntries), asShardEntry(entry));
 };
+/**
+ * @param {API.BlockFetcher} blocks
+ * @param {API.BatcherShard} shard
+ * @param {string} key The key of the value to delete.
+ * @returns {Promise<void>}
+ */
+export const del = async (blocks, shard, key) => {
+    const shards = new ShardFetcher(blocks);
+    const dest = await traverse(shards, shard, key);
+    const entryidx = dest.shard.entries.findIndex(([k]) => k === dest.key);
+    if (entryidx === -1)
+        return;
+    const entry = dest.shard.entries[entryidx];
+    if (Array.isArray(entry[1])) {
+        // cannot delete a shard-only entry (no value)
+        if (entry[1][1] == null)
+            return;
+        // remove value but keep shard link
+        dest.shard.entries[entryidx] = [entry[0], /** @type {API.ShardEntryLinkValue | API.ShardEntryShardValue} */ ([entry[1][0]])];
+    }
+    else {
+        // remove the entry entirely
+        dest.shard.entries.splice(entryidx, 1);
+    }
+};
 /**
  * Traverse from the passed shard through to the correct shard for the passed
  * key.

package/dist/src/crdt/batch/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/crdt/batch/index.js"],"names":[],"mappings":";AA0JO,+BAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAC5B,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAEmC;oCArJpC,sBAAsB;qBAJrC,UAAU"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/crdt/batch/index.js"],"names":[],"mappings":";AAoKO,+BAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAC5B,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAEmC;oCA/JpC,sBAAsB;qBAJrC,UAAU"}

package/dist/src/crdt/batch/index.js

@@ -50,6 +50,16 @@ class Batcher {
         await Batch.put(this.blocks, this, key, value);
         this.ops.push({ type: 'put', key, value });
     }
+    /**
+     * @param {string} key The key of the value to delete.
+     * @returns {Promise<void>}
+     */
+    async del(key) {
+        if (this.#committed)
+            throw new BatchCommittedError();
+        await Batch.del(this.blocks, this, key);
+        this.ops.push({ type: 'del', key });
+    }
     async commit() {
         if (this.#committed)
             throw new BatchCommittedError();

package/dist/src/crdt/index.d.ts

@@ -1,5 +1,5 @@
 export function put(blocks: API.BlockFetcher, head: API.EventLink<API.Operation>[], key: string, value: API.UnknownLink): Promise<API.Result>;
-export function del(blocks: API.BlockFetcher, head: API.EventLink<API.Operation>[], key: string, options?: object): Promise<API.Result>;
+export function del(blocks: API.BlockFetcher, head: API.EventLink<API.Operation>[], key: string): Promise<API.Result>;
 export function root(blocks: API.BlockFetcher, head: API.EventLink<API.Operation>[]): Promise<{
     root: API.ShardLink;
 } & API.ShardDiff>;

package/dist/src/crdt/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crdt/index.js"],"names":[],"mappings":"AAmBO,4BANI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,OAC9B,MAAM,SACN,GAAG,CAAC,WAAW,GACb,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAoG/B;AAYM,4BANI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,OAC9B,MAAM,YACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAI/B;AAYM,6BAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAC5B,OAAO,CAAC;IAAE,IAAI,EAAE,GAAG,CAAC,SAAS,CAAA;CAAE,GAAG,GAAG,CAAC,SAAS,CAAC,CAsE5D;AAOM,4BAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,OAC9B,MAAM,6GAShB;AAOM,gCAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,YAC9B,GAAG,CAAC,cAAc,kEAS5B;qBA9OoB,UAAU"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crdt/index.js"],"names":[],"mappings":"AAmBO,4BANI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,OAC9B,MAAM,SACN,GAAG,CAAC,WAAW,GACb,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAyB/B;AAWM,4BALI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,OAC9B,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAO/B;AAsEM,6BAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAC5B,OAAO,CAAC;IAAE,IAAI,EAAE,GAAG,CAAC,SAAS,CAAA;CAAE,GAAG,GAAG,CAAC,SAAS,CAAC,CA0E5D;AAOM,4BAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,OAC9B,MAAM,6GAYhB;AAOM,gCAJI,GAAG,CAAC,YAAY,QAChB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,YAC9B,GAAG,CAAC,cAAc,kEAY5B;qBAzOoB,UAAU"}

package/dist/src/crdt/index.js

@@ -17,9 +17,9 @@ import * as Batch from '../batch/index.js';
  * @returns {Promise<API.Result>}
  */
 export const put = async (blocks, head, key, value) => {
-    const mblocks = new MemoryBlockstore();
-    blocks = new MultiBlockFetcher(mblocks, blocks);
     if (!head.length) {
+        const mblocks = new MemoryBlockstore();
+        blocks = new MultiBlockFetcher(mblocks, blocks);
         const shard = await ShardBlock.create();
         mblocks.putSync(shard.cid, shard.bytes);
         const result = await Pail.put(blocks, shard.cid, key, value);
@@ -35,65 +35,58 @@ export const put = async (blocks, head, key, value) => {
             event
         };
     }
-    /** @type {EventFetcher<API.Operation>} */
-    const events = new EventFetcher(blocks);
-    const ancestor = await findCommonAncestor(events, head);
-    if (!ancestor)
-        throw new Error('failed to find common ancestor event');
-    const aevent = await events.get(ancestor);
-    let { root } = aevent.value.data;
-    const sorted = await findSortedEvents(events, head, ancestor);
-    /** @type {Map<string, API.ShardBlockView>} */
-    const additions = new Map();
-    /** @type {Map<string, API.ShardBlockView>} */
-    const removals = new Map();
-    for (const { value: event } of sorted) {
-        let result;
-        if (event.data.type === 'put') {
-            result = await Pail.put(blocks, root, event.data.key, event.data.value);
-        }
-        else if (event.data.type === 'del') {
-            result = await Pail.del(blocks, root, event.data.key);
-        }
-        else if (event.data.type === 'batch') {
-            const batch = await Batch.create(blocks, root);
-            for (const op of event.data.ops) {
-                if (op.type !== 'put')
-                    throw new Error(`unsupported batch operation: ${op.type}`);
-                await batch.put(op.key, op.value);
-            }
-            result = await batch.commit();
-        }
-        else {
-            // @ts-expect-error type does not exist on never
-            throw new Error(`unknown operation: ${event.data.type}`);
-        }
-        root = result.root;
-        for (const a of result.additions) {
-            mblocks.putSync(a.cid, a.bytes);
-            additions.set(a.cid.toString(), a);
-        }
-        for (const r of result.removals) {
-            removals.set(r.cid.toString(), r);
-        }
-    }
-    const result = await Pail.put(blocks, root, key, value);
-    // if we didn't change the pail we're done
-    if (result.root.toString() === root.toString()) {
-        return { root, additions: [], removals: [], head };
-    }
-    for (const a of result.additions) {
+    return applyOperation(blocks, head, { type: 'put', key, value }, (b, r) => Pail.put(b, r, key, value));
+};
+/**
+ * Delete the value for the given key from the bucket. If the key is not found
+ * no operation occurs.
+ *
+ * @param {API.BlockFetcher} blocks Bucket block storage.
+ * @param {API.EventLink<API.Operation>[]} head Merkle clock head.
+ * @param {string} key The key of the value to delete.
+ * @returns {Promise<API.Result>}
+ */
+export const del = async (blocks, head, key) => {
+    if (!head.length)
+        throw new Error('cannot delete from empty clock');
+    return applyOperation(blocks, head, { type: 'del', key }, (b, r) => Pail.del(b, r, key));
+};
+/**
+ * Resolve the current root, apply an operation, create a clock event, and
+ * return the updated head.
+ *
+ * @param {API.BlockFetcher} blocks Bucket block storage.
+ * @param {API.EventLink<API.Operation>[]} head Merkle clock head.
+ * @param {API.PutOperation | API.DeleteOperation} op Operation data (without root).
+ * @param {(blocks: API.BlockFetcher, root: API.ShardLink) => Promise<{ root: API.ShardLink } & API.ShardDiff>} fn
+ * @returns {Promise<API.Result>}
+ */
+const applyOperation = async (blocks, head, op, fn) => {
+    const mblocks = new MemoryBlockstore();
+    blocks = new MultiBlockFetcher(mblocks, blocks);
+    const resolved = await root(blocks, head);
+    for (const a of resolved.additions) {
         mblocks.putSync(a.cid, a.bytes);
-        additions.set(a.cid.toString(), a);
     }
-    for (const r of result.removals) {
-        removals.set(r.cid.toString(), r);
+    const result = await fn(blocks, resolved.root);
+    if (result.root.toString() === resolved.root.toString()) {
+        return { root: resolved.root, additions: [], removals: [], head };
     }
     /** @type {API.Operation} */
-    const data = { type: 'put', root: result.root, key, value };
+    const data = { ...op, root: result.root };
     const event = await EventBlock.create(data, head);
     mblocks.putSync(event.cid, event.bytes);
     head = await Clock.advance(blocks, head, event.cid);
+    /** @type {Map<string, API.ShardBlockView>} */
+    const additions = new Map();
+    for (const a of [...resolved.additions, ...result.additions]) {
+        additions.set(a.cid.toString(), a);
+    }
+    /** @type {Map<string, API.ShardBlockView>} */
+    const removals = new Map();
+    for (const r of [...resolved.removals, ...result.removals]) {
+        removals.set(r.cid.toString(), r);
+    }
     // filter blocks that were added _and_ removed
     for (const k of removals.keys()) {
         if (additions.has(k)) {
@@ -109,19 +102,6 @@ export const put = async (blocks, head, key, value) => {
         event
     };
 };
-/**
- * Delete the value for the given key from the bucket. If the key is not found
- * no operation occurs.
- *
- * @param {API.BlockFetcher} blocks Bucket block storage.
- * @param {API.EventLink<API.Operation>[]} head Merkle clock head.
- * @param {string} key The key of the value to delete.
- * @param {object} [options]
- * @returns {Promise<API.Result>}
- */
-export const del = async (blocks, head, key, options) => {
-    throw new Error('not implemented');
-};
 /**
  * Determine the effective pail root given the current merkle clock head.
  *
@@ -165,15 +145,20 @@ export const root = async (blocks, head) => {
         else if (event.data.type === 'batch') {
             const batch = await Batch.create(blocks, root);
             for (const op of event.data.ops) {
-                if (op.type !== 'put')
-                    throw new Error(`unsupported batch operation: ${op.type}`);
-                await batch.put(op.key, op.value);
+                if (op.type === 'put') {
+                    await batch.put(op.key, op.value);
+                }
+                else if (op.type === 'del') {
+                    await batch.del(op.key);
+                }
+                else {
+                    throw new Error(`unsupported batch operation: ${ /** @type {any} */(op).type}`);
+                }
             }
             result = await batch.commit();
         }
         else {
-            // @ts-expect-error type does not exist on never
-            throw new Error(`unknown operation: ${event.data.type}`);
+            throw new Error(`unknown operation: ${ /** @type {any} */(event.data).type}`);
         }
         root = result.root;
         for (const a of result.additions) {
@@ -235,7 +220,7 @@ export const entries = async function* (blocks, head, options) {
 const findCommonAncestor = async (events, children) => {
     if (!children.length)
         return;
-    const candidates = children.map(c => [c]);
+    const candidates = children.map((c) => [c]);
     while (true) {
         let changed = false;
         for (const c of candidates) {
@@ -269,14 +254,14 @@ const findAncestorCandidate = async (events, root) => {
  * @param  {Array<T[]>} arrays
  */
 const findCommonString = (arrays) => {
-    arrays = arrays.map(a => [...a]);
+    arrays = arrays.map((a) => [...a]);
     for (const arr of arrays) {
         for (const item of arr) {
             let matched = true;
             for (const other of arrays) {
                 if (arr === other)
                     continue;
-                matched = other.some(i => String(i) === String(item));
+                matched = other.some((i) => String(i) === String(item));
                 if (!matched)
                     break;
             }
@@ -298,7 +283,7 @@ const findSortedEvents = async (events, head, tail) => {
     // get weighted events - heavier events happened first
     /** @type {Map<string, { event: API.EventBlockView<API.Operation>, weight: number }>} */
     const weights = new Map();
-    const all = await Promise.all(head.map(h => findEvents(events, h, tail)));
+    const all = await Promise.all(head.map((h) => findEvents(events, h, tail)));
     for (const arr of all) {
         for (const { event, depth } of arr) {
             const info = weights.get(event.cid.toString());
@@ -325,7 +310,126 @@ const findSortedEvents = async (events, head, tail) => {
     // sort by weight, and by CID within weight
     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));
+        .flatMap(([, events]) => removeConcurrentDeletes(events).sort((a, b) => String(a.cid) < String(b.cid) ? -1 : 1));
+};
+/**
+ * Remove concurrent events that delete the same key or delete/put the same key. The conflict resolution rules are as follows:
+ * - If two or more concurrent events delete the same key, all but one of the delete events are removed (so the key is still deleted).
+ * - If one or more concurrent events delete a key while another event puts a value for the same key, the put wins (i.e. the delete events are removed).
+ * @param {API.EventBlockView<API.Operation>[]} events
+ * @returns {API.EventBlockView<API.Operation>[]}
+ */
+const removeConcurrentDeletes = (events) => {
+    // Simplify batch events: within a batch, ops are ordered so only the last
+    // operation per key represents the net effect. e.g. [put a, put b, del a]
+    // simplifies to [put b, del a] — the earlier put a is overridden.
+    // @ts-expect-error creating modified views with simplified ops
+    events = events.map((event) => {
+        const { data } = event.value;
+        if (data.type !== 'batch')
+            return event;
+        /** @type {Map<string, number>} */
+        const lastIndex = new Map();
+        for (let i = 0; i < data.ops.length; i++) {
+            lastIndex.set(data.ops[i].key, i);
+        }
+        const simplified = data.ops.filter((op, i) => lastIndex.get(op.key) === i);
+        if (simplified.length === data.ops.length)
+            return event;
+        return {
+            cid: event.cid,
+            bytes: event.bytes,
+            value: { ...event.value, data: { ...data, ops: simplified } }
+        };
+    });
+    /** @type {Map<string, number>} */
+    const delCounts = new Map();
+    /** @type {Set<string>} */
+    const putKeys = new Set();
+    for (const event of events) {
+        const { data } = event.value;
+        if (data.type === 'put') {
+            putKeys.add(data.key);
+        }
+        else if (data.type === 'del') {
+            delCounts.set(data.key, (delCounts.get(data.key) || 0) + 1);
+        }
+        else if (data.type === 'batch') {
+            for (const op of data.ops) {
+                if (op.type === 'put') {
+                    putKeys.add(op.key);
+                }
+                else if (op.type === 'del') {
+                    delCounts.set(op.key, (delCounts.get(op.key) || 0) + 1);
+                }
+            }
+        }
+    }
+    // Keys whose delete operations should be deduplicated: put wins over delete,
+    // and multiple concurrent deletes are collapsed to one.
+    /** @type {Set<string>} */
+    const putWinsKeys = new Set();
+    /** @type {Set<string>} */
+    const dedupeDelKeys = new Set();
+    for (const [key, count] of delCounts) {
+        if (putKeys.has(key)) {
+            putWinsKeys.add(key);
+        }
+        else if (count > 1) {
+            dedupeDelKeys.add(key);
+        }
+    }
+    if (putWinsKeys.size === 0 && dedupeDelKeys.size === 0)
+        return events;
+    // Track which deduped-delete keys have already had their first delete kept
+    /** @type {Set<string>} */
+    const keptDeletes = new Set();
+    /** @type {API.EventBlockView<API.Operation>[]} */
+    const result = [];
+    for (const event of events) {
+        const { data } = event.value;
+        if (data.type === 'del') {
+            if (putWinsKeys.has(data.key))
+                continue;
+            if (dedupeDelKeys.has(data.key)) {
+                if (keptDeletes.has(data.key))
+                    continue;
+                keptDeletes.add(data.key);
+            }
+            result.push(event);
+        }
+        else if (data.type === 'batch') {
+            const filteredOps = data.ops.filter((op) => {
+                if (op.type !== 'del')
+                    return true;
+                if (putWinsKeys.has(op.key))
+                    return false;
+                if (dedupeDelKeys.has(op.key)) {
+                    if (keptDeletes.has(op.key))
+                        return false;
+                    keptDeletes.add(op.key);
+                }
+                return true;
+            });
+            if (filteredOps.length === 0)
+                continue;
+            if (filteredOps.length !== data.ops.length) {
+                // @ts-expect-error creating a modified view with filtered ops
+                result.push({
+                    cid: event.cid,
+                    bytes: event.bytes,
+                    value: { ...event.value, data: { ...data, ops: filteredOps } }
+                });
+            }
+            else {
+                result.push(event);
+            }
+        }
+        else {
+            result.push(event);
+        }
+    }
+    return result;
 };
 /**
  * @param {EventFetcher<API.Operation>} events
@@ -339,6 +443,6 @@ const findEvents = async (events, start, end, depth = 0) => {
     const { parents } = event.value;
     if (parents.length === 1 && String(parents[0]) === String(end))
         return acc;
-    const rest = await Promise.all(parents.map(p => findEvents(events, p, end, depth + 1)));
+    const rest = await Promise.all(parents.map((p) => findEvents(events, p, end, depth + 1)));
     return acc.concat(...rest);
 };

package/dist/test/batch.test.js

@@ -87,6 +87,98 @@ describe('batch', () => {
         await batch.commit();
         await expect(async () => batch.commit()).rejects.toThrowError(/batch already committed/);
     });
+    it('batches dels', async () => {
+        const rootblk = await ShardBlock.create();
+        const blocks = new Blockstore();
+        await blocks.put(rootblk.cid, rootblk.bytes);
+        // put some keys
+        const keys = [];
+        for (let i = 0; i < 10; i++) {
+            keys.push(`test${randomString(10)}`);
+        }
+        /** @type {API.ShardLink} */
+        let current = rootblk.cid;
+        for (const key of keys) {
+            const { root, additions } = await Pail.put(blocks, current, key, await randomCID());
+            current = root;
+            for (const b of additions)
+                blocks.putSync(b.cid, b.bytes);
+        }
+        // batch-delete the first 5
+        const batch = await Batch.create(blocks, current);
+        for (const key of keys.slice(0, 5)) {
+            await batch.del(key);
+        }
+        const { root, additions, removals } = await batch.commit();
+        for (const b of removals)
+            blocks.deleteSync(b.cid);
+        for (const b of additions)
+            blocks.putSync(b.cid, b.bytes);
+        // deleted keys should be gone
+        for (const key of keys.slice(0, 5)) {
+            const value = await Pail.get(blocks, root, key);
+            assert.equal(value, undefined);
+        }
+        // remaining keys should still exist
+        for (const key of keys.slice(5)) {
+            const value = await Pail.get(blocks, root, key);
+            assert(value);
+        }
+    });
+    it('mixed put and del in same batch', async () => {
+        const rootblk = await ShardBlock.create();
+        const blocks = new Blockstore();
+        await blocks.put(rootblk.cid, rootblk.bytes);
+        // put initial keys
+        /** @type {API.ShardLink} */
+        let current = rootblk.cid;
+        const value0 = await randomCID();
+        const res0 = await Pail.put(blocks, current, 'apple', value0);
+        current = res0.root;
+        for (const b of res0.additions)
+            blocks.putSync(b.cid, b.bytes);
+        const res1 = await Pail.put(blocks, current, 'banana', await randomCID());
+        current = res1.root;
+        for (const b of res1.additions)
+            blocks.putSync(b.cid, b.bytes);
+        // batch: delete apple, put cherry
+        const cherryValue = await randomCID();
+        const batch = await Batch.create(blocks, current);
+        await batch.del('apple');
+        await batch.put('cherry', cherryValue);
+        const { root, additions, removals } = await batch.commit();
+        for (const b of removals)
+            blocks.deleteSync(b.cid);
+        for (const b of additions)
+            blocks.putSync(b.cid, b.bytes);
+        assert.equal(await Pail.get(blocks, root, 'apple'), undefined);
+        assert(await Pail.get(blocks, root, 'banana'));
+        const cherry = await Pail.get(blocks, root, 'cherry');
+        assert(cherry);
+        assert.equal(cherry.toString(), cherryValue.toString());
+    });
+    it('del non-existent key is a no-op', async () => {
+        const rootblk = await ShardBlock.create();
+        const blocks = new Blockstore();
+        await blocks.put(rootblk.cid, rootblk.bytes);
+        const { root: r0, additions: a0 } = await Pail.put(blocks, rootblk.cid, 'apple', await randomCID());
+        for (const b of a0)
+            blocks.putSync(b.cid, b.bytes);
+        const batch = await Batch.create(blocks, r0);
+        await batch.del('nonexistent');
+        const { root } = await batch.commit();
+        // root should be unchanged
+        assert.equal(root.toString(), r0.toString());
+    });
+    it('error when del after commit', async () => {
+        const root = await ShardBlock.create();
+        const blocks = new Blockstore();
+        await blocks.put(root.cid, root.bytes);
+        const batch = await Batch.create(blocks, root.cid);
+        await batch.put('test', await randomCID());
+        await batch.commit();
+        await expect(async () => batch.del('test')).rejects.toThrowError(/batch already committed/);
+    });
     it('traverses existing shards to put values', async () => {
         const rootblk = await ShardBlock.create();
         const blocks = new Blockstore();