@peerbit/log 4.1.11 → 4.2.1

package/dist/src/log.js

@@ -1,13 +1,37 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
 };
-var Log_1;
 import { deserialize, field, fixedArray, variant } from "@dao-xyz/borsh";
 import {} from "@peerbit/any-store";
 import { cidifyString } from "@peerbit/blocks-interface";
@@ -33,864 +57,876 @@ export const ENTRY_JOIN_SHAPE = {
     hash: true,
     meta: { type: true, next: true, gid: true, clock: true },
 };
-let Log = Log_1 = class Log {
-    _id;
-    /* private _sortFn!: Sorting.ISortFunction; */
-    _storage;
-    _hlc;
-    // Identity
-    _identity;
-    // Keeping track of entries
-    _entryIndex;
-    /* 	private _headsIndex!: HeadsIndex<T>;
-        private _values!: Values<T>;
-     */
-    // Index of all next pointers in this log
-    /* private _nextsIndex!: Map<string, Set<string>>; */
-    _keychain;
-    _encoding;
-    _trim;
-    _canAppend;
-    _onChange;
-    _closed = true;
-    _closeController;
-    _loadedOnce = false;
-    _indexer;
-    _joining; // entry hashes that are currently joining into this log
-    _sortFn;
-    constructor(properties) {
-        this._id = properties?.id || randomBytes(32);
-    }
-    async open(store, identity, options = {}) {
-        if (store == null) {
-            throw LogError.BlockStoreNotDefinedError();
-        }
-        if (identity == null) {
-            throw new Error("Identity is required");
-        }
-        if (this.closed === false) {
-            throw new Error("Already open");
-        }
-        this._closeController = new AbortController();
-        const { encoding, trim, keychain, indexer, onGidRemoved, sortFn } = options;
-        // TODO do correctly with tie breaks
-        this._sortFn = sortFn || LastWriteWins;
-        this._storage = store;
-        this._indexer = indexer || (await create());
-        await this._indexer.start?.();
-        this._encoding = encoding || NO_ENCODING;
-        this._joining = new Map();
+let Log = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let __id_decorators;
+    let __id_initializers = [];
+    let __id_extraInitializers = [];
+    var Log = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __id_decorators = [field({ type: fixedArray("u8", 32) })];
+            __esDecorate(null, null, __id_decorators, { kind: "field", name: "_id", static: false, private: false, access: { has: obj => "_id" in obj, get: obj => obj._id, set: (obj, value) => { obj._id = value; } }, metadata: _metadata }, __id_initializers, __id_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Log = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        _id = __runInitializers(this, __id_initializers, void 0);
+        /* private _sortFn!: Sorting.ISortFunction; */
+        _storage = __runInitializers(this, __id_extraInitializers);
+        _hlc;
         // Identity
-        this._identity = identity;
-        // encoder/decoder
-        this._keychain = keychain;
-        // Clock
-        this._hlc = new HLC();
-        const id = this.id;
-        if (!id) {
-            throw new Error("Id not set");
-        }
-        this._entryIndex = new EntryIndex({
-            store: this._storage,
-            init: (e) => e.init(this),
-            onGidRemoved,
-            index: await (await this._indexer.scope("heads")).init({ schema: ShallowEntry }),
-            publicKey: this._identity.publicKey,
-            sort: this._sortFn,
-        });
-        await this._entryIndex.init();
-        /* 	this._values = new Values(this._entryIndex, this._sortFn); */
-        this._trim = new Trim({
-            index: this._entryIndex,
-            deleteNode: async (node) => {
-                const resolved = await this.get(node.hash);
-                await this._entryIndex.delete(node.hash);
-                await this._storage.rm(node.hash);
-                return resolved;
-            },
-            sortFn: this._sortFn,
-            getLength: () => this.length,
-        }, trim);
-        this._canAppend = async (entry) => {
-            if (options?.canAppend) {
-                if (!(await options.canAppend(entry))) {
-                    return false;
+        _identity;
+        // Keeping track of entries
+        _entryIndex;
+        /* 	private _headsIndex!: HeadsIndex<T>;
+            private _values!: Values<T>;
+         */
+        // Index of all next pointers in this log
+        /* private _nextsIndex!: Map<string, Set<string>>; */
+        _keychain;
+        _encoding;
+        _trim;
+        _canAppend;
+        _onChange;
+        _closed = true;
+        _closeController;
+        _loadedOnce = false;
+        _indexer;
+        _joining; // entry hashes that are currently joining into this log
+        _sortFn;
+        constructor(properties) {
+            this._id = properties?.id || randomBytes(32);
+        }
+        async open(store, identity, options = {}) {
+            if (store == null) {
+                throw LogError.BlockStoreNotDefinedError();
+            }
+            if (identity == null) {
+                throw new Error("Identity is required");
+            }
+            if (this.closed === false) {
+                throw new Error("Already open");
+            }
+            this._closeController = new AbortController();
+            const { encoding, trim, keychain, indexer, onGidRemoved, sortFn } = options;
+            // TODO do correctly with tie breaks
+            this._sortFn = sortFn || LastWriteWins;
+            this._storage = store;
+            this._indexer = indexer || (await create());
+            await this._indexer.start?.();
+            this._encoding = encoding || NO_ENCODING;
+            this._joining = new Map();
+            // Identity
+            this._identity = identity;
+            // encoder/decoder
+            this._keychain = keychain;
+            // Clock
+            this._hlc = new HLC();
+            const id = this.id;
+            if (!id) {
+                throw new Error("Id not set");
+            }
+            this._entryIndex = new EntryIndex({
+                store: this._storage,
+                init: (e) => e.init(this),
+                onGidRemoved,
+                index: await (await this._indexer.scope("heads")).init({ schema: ShallowEntry }),
+                publicKey: this._identity.publicKey,
+                sort: this._sortFn,
+            });
+            await this._entryIndex.init();
+            /* 	this._values = new Values(this._entryIndex, this._sortFn); */
+            this._trim = new Trim({
+                index: this._entryIndex,
+                deleteNode: async (node) => {
+                    const resolved = await this.get(node.hash);
+                    await this._entryIndex.delete(node.hash);
+                    await this._storage.rm(node.hash);
+                    return resolved;
+                },
+                sortFn: this._sortFn,
+                getLength: () => this.length,
+            }, trim);
+            this._canAppend = async (entry) => {
+                if (options?.canAppend) {
+                    if (!(await options.canAppend(entry))) {
+                        return false;
+                    }
                 }
+                return true;
+            };
+            this._onChange = options?.onChange;
+            this._closed = false;
+            this._closeController = new AbortController();
+        }
+        _idString;
+        get idString() {
+            if (!this.id) {
+                throw new Error("Id not set");
             }
-            return true;
-        };
-        this._onChange = options?.onChange;
-        this._closed = false;
-        this._closeController = new AbortController();
-    }
-    _idString;
-    get idString() {
-        if (!this.id) {
-            throw new Error("Id not set");
+            return this._idString || (this._idString = Log.createIdString(this.id));
         }
-        return this._idString || (this._idString = Log_1.createIdString(this.id));
-    }
-    static createIdString(id) {
-        return sha256Base64Sync(id);
-    }
-    get id() {
-        return this._id;
-    }
-    set id(id) {
-        if (this.closed === false) {
-            throw new Error("Can not change id after open");
+        static createIdString(id) {
+            return sha256Base64Sync(id);
         }
-        this._idString = undefined;
-        this._id = id;
-    }
-    /**
-     * Returns the length of the log.
-     */
-    get length() {
-        if (this._closed) {
-            throw new Error("Closed");
-        }
-        return this._entryIndex.length;
-    }
-    get canAppend() {
-        return this._canAppend;
-    }
-    /**
-     * Checks if a entry is part of the log
-     * @param {string} hash The hash of the entry
-     * @returns {boolean}
-     */
-    has(cid) {
-        return this._entryIndex.has(cid);
-    }
-    /**
-     * Get all entries sorted. Don't use this method anywhere where performance matters
-     */
-    async toArray() {
-        // we call init, because the values might be unitialized
-        return this.entryIndex.iterate([], this.sortFn.sort, true).all();
-    }
-    /**
-     * Returns the head index
-     */
-    getHeads(resolve = false) {
-        return this.entryIndex.getHeads(undefined, resolve);
-    }
-    /**
-     * Returns an array of Entry objects that reference entries which
-     * are not in the log currently.
-     * @returns {Array<Entry<T>>}
-     */
-    async getTails() {
-        return Log_1.findTails(await this.toArray());
-    }
-    /**
-     * Returns an array of hashes that are referenced by entries which
-     * are not in the log currently.
-     * @returns {Array<string>} Array of hashes
-     */
-    async getTailHashes() {
-        return Log_1.findTailHashes(await this.toArray());
-    }
-    /**
-     * Get local HLC
-     */
-    get hlc() {
-        return this._hlc;
-    }
-    get identity() {
-        return this._identity;
-    }
-    get blocks() {
-        return this._storage;
-    }
-    get entryIndex() {
-        return this._entryIndex;
-    }
-    get keychain() {
-        return this._keychain;
-    }
-    get encoding() {
-        return this._encoding;
-    }
-    get sortFn() {
-        return this._sortFn;
-    }
-    get closed() {
-        return this._closed;
-    }
-    /**
-     * Set the identity for the log
-     * @param {Identity} [identity] The identity to be set
-     */
-    setIdentity(identity) {
-        this._identity = identity;
-    }
-    /**
-     * Get an entry.
-     * @param {string} [hash] The hashes of the entry
-     */
-    get(hash, options) {
-        return this._entryIndex.get(hash, options
-            ? {
-                type: "full",
-                remote: options?.remote && {
-                    timeout: typeof options?.remote !== "boolean"
-                        ? options.remote.timeout
-                        : undefined,
-                },
-                ignoreMissing: true, // always return undefined instead of throwing errors on missing entries
-            }
-            : { type: "full", ignoreMissing: true });
-    }
-    /**
-     * Get a entry with shallow representation
-     * @param {string} [hash] The hashes of the entry
-     */
-    async getShallow(hash) {
-        return (await this._entryIndex.getShallow(hash))?.value;
-    }
-    async getReferenceSamples(from, options) {
-        const hashes = new Set();
-        const pointerCount = options?.pointerCount || 0;
-        const memoryLimit = options?.memoryLimit;
-        const maxDistance = Math.min(pointerCount, this.entryIndex.length);
-        if (maxDistance === 0) {
-            return [];
+        get id() {
+            return this._id;
         }
-        hashes.add(from.hash);
-        let memoryCounter = from.payload.byteLength;
-        if (from.meta.next?.length > 0 && pointerCount >= 2) {
-            let next = new Set(from.meta.next);
-            let prev = 2;
-            outer: for (let i = 2; i <= maxDistance - 1; i *= 2) {
-                for (let j = prev; j < i; j++) {
-                    if (next.size === 0) {
-                        break outer;
-                    }
-                    const nextNext = new Set();
-                    for (const n of next) {
-                        const nentry = await this.get(n);
-                        if (nentry) {
-                            for (const n2 of nentry.meta.next) {
-                                nextNext.add(n2);
+        set id(id) {
+            if (this.closed === false) {
+                throw new Error("Can not change id after open");
+            }
+            this._idString = undefined;
+            this._id = id;
+        }
+        /**
+         * Returns the length of the log.
+         */
+        get length() {
+            if (this._closed) {
+                throw new Error("Closed");
+            }
+            return this._entryIndex.length;
+        }
+        get canAppend() {
+            return this._canAppend;
+        }
+        /**
+         * Checks if a entry is part of the log
+         * @param {string} hash The hash of the entry
+         * @returns {boolean}
+         */
+        has(cid) {
+            return this._entryIndex.has(cid);
+        }
+        /**
+         * Get all entries sorted. Don't use this method anywhere where performance matters
+         */
+        async toArray() {
+            // we call init, because the values might be unitialized
+            return this.entryIndex.iterate([], this.sortFn.sort, true).all();
+        }
+        /**
+         * Returns the head index
+         */
+        getHeads(resolve = false) {
+            return this.entryIndex.getHeads(undefined, resolve);
+        }
+        /**
+         * Returns an array of Entry objects that reference entries which
+         * are not in the log currently.
+         * @returns {Array<Entry<T>>}
+         */
+        async getTails() {
+            return Log.findTails(await this.toArray());
+        }
+        /**
+         * Returns an array of hashes that are referenced by entries which
+         * are not in the log currently.
+         * @returns {Array<string>} Array of hashes
+         */
+        async getTailHashes() {
+            return Log.findTailHashes(await this.toArray());
+        }
+        /**
+         * Get local HLC
+         */
+        get hlc() {
+            return this._hlc;
+        }
+        get identity() {
+            return this._identity;
+        }
+        get blocks() {
+            return this._storage;
+        }
+        get entryIndex() {
+            return this._entryIndex;
+        }
+        get keychain() {
+            return this._keychain;
+        }
+        get encoding() {
+            return this._encoding;
+        }
+        get sortFn() {
+            return this._sortFn;
+        }
+        get closed() {
+            return this._closed;
+        }
+        /**
+         * Set the identity for the log
+         * @param {Identity} [identity] The identity to be set
+         */
+        setIdentity(identity) {
+            this._identity = identity;
+        }
+        /**
+         * Get an entry.
+         * @param {string} [hash] The hashes of the entry
+         */
+        get(hash, options) {
+            return this._entryIndex.get(hash, options
+                ? {
+                    type: "full",
+                    remote: options?.remote && {
+                        timeout: typeof options?.remote !== "boolean"
+                            ? options.remote.timeout
+                            : undefined,
+                    },
+                    ignoreMissing: true, // always return undefined instead of throwing errors on missing entries
+                }
+                : { type: "full", ignoreMissing: true });
+        }
+        /**
+         * Get a entry with shallow representation
+         * @param {string} [hash] The hashes of the entry
+         */
+        async getShallow(hash) {
+            return (await this._entryIndex.getShallow(hash))?.value;
+        }
+        async getReferenceSamples(from, options) {
+            const hashes = new Set();
+            const pointerCount = options?.pointerCount || 0;
+            const memoryLimit = options?.memoryLimit;
+            const maxDistance = Math.min(pointerCount, this.entryIndex.length);
+            if (maxDistance === 0) {
+                return [];
+            }
+            hashes.add(from.hash);
+            let memoryCounter = from.payload.byteLength;
+            if (from.meta.next?.length > 0 && pointerCount >= 2) {
+                let next = new Set(from.meta.next);
+                let prev = 2;
+                outer: for (let i = 2; i <= maxDistance - 1; i *= 2) {
+                    for (let j = prev; j < i; j++) {
+                        if (next.size === 0) {
+                            break outer;
+                        }
+                        const nextNext = new Set();
+                        for (const n of next) {
+                            const nentry = await this.get(n);
+                            if (nentry) {
+                                for (const n2 of nentry.meta.next) {
+                                    nextNext.add(n2);
+                                }
                             }
                         }
+                        next = nextNext;
                     }
-                    next = nextNext;
-                }
-                prev = i;
-                if (next) {
-                    for (const n of next) {
-                        if (!memoryLimit) {
-                            hashes.add(n);
-                        }
-                        else {
-                            const entry = await this.get(n);
-                            if (!entry) {
-                                break outer;
+                    prev = i;
+                    if (next) {
+                        for (const n of next) {
+                            if (!memoryLimit) {
+                                hashes.add(n);
                             }
-                            memoryCounter += entry.payload.byteLength;
-                            if (memoryCounter > memoryLimit) {
+                            else {
+                                const entry = await this.get(n);
+                                if (!entry) {
+                                    break outer;
+                                }
+                                memoryCounter += entry.payload.byteLength;
+                                if (memoryCounter > memoryLimit) {
+                                    break outer;
+                                }
+                                hashes.add(n);
+                            }
+                            if (hashes.size === pointerCount) {
                                 break outer;
                             }
-                            hashes.add(n);
-                        }
-                        if (hashes.size === pointerCount) {
-                            break outer;
                         }
                     }
                 }
             }
-        }
-        const ret = [];
-        for (const hash of hashes) {
-            const entry = await this.get(hash);
-            if (entry) {
-                ret.push(entry);
+            const ret = [];
+            for (const hash of hashes) {
+                const entry = await this.get(hash);
+                if (entry) {
+                    ret.push(entry);
+                }
             }
-        }
-        return ret;
-    }
-    /**
-     * Append an entry to the log.
-     * @param {T} data The data to be appended
-     * @param {AppendOptions} [options] The options for the append
-     * @returns {{ entry: Entry<T>; removed: ShallowEntry[] }} The appended entry and an array of removed entries
-     */
-    async append(data, options = {}) {
-        // Update the clock (find the latest clock)
-        if (options.meta?.next) {
-            for (const n of options.meta.next) {
-                if (!n.hash)
-                    throw new Error("Expecting nexts to already be saved. missing hash for one or more entries");
-            }
-        }
-        /* await this.load({ reload: false }); */
-        const nexts = options.meta?.next ||
-            (await this.entryIndex
-                .getHeads(undefined, { type: "shape", shape: Sorting.ENTRY_SORT_SHAPE })
-                .all());
-        // Calculate max time for log/graph
-        const clock = new Clock({
-            id: this._identity.publicKey.bytes,
-            timestamp: options?.meta?.timestamp || this._hlc.now(),
-        });
-        const entry = await EntryV0.create({
-            store: this._storage,
-            identity: options.identity || this._identity,
-            signers: options.signers,
-            data,
-            meta: {
-                clock,
-                type: options.meta?.type,
-                gidSeed: options.meta?.gidSeed,
-                data: options.meta?.data,
-                next: nexts,
-            },
-            encoding: this._encoding,
-            encryption: options.encryption
-                ? {
-                    keypair: options.encryption.keypair,
-                    receiver: {
-                        ...options.encryption.receiver,
-                    },
+            return ret;
+        }
+        /**
+         * Append an entry to the log.
+         * @param {T} data The data to be appended
+         * @param {AppendOptions} [options] The options for the append
+         * @returns {{ entry: Entry<T>; removed: ShallowEntry[] }} The appended entry and an array of removed entries
+         */
+        async append(data, options = {}) {
+            // Update the clock (find the latest clock)
+            if (options.meta?.next) {
+                for (const n of options.meta.next) {
+                    if (!n.hash)
+                        throw new Error("Expecting nexts to already be saved. missing hash for one or more entries");
                 }
-                : undefined,
-            canAppend: options.canAppend || this._canAppend,
-        });
-        if (!entry.hash) {
-            throw new Error("Unexpected");
-        }
-        if (entry.meta.type !== EntryType.CUT) {
-            for (const e of nexts) {
-                if (!(await this.has(e.hash))) {
-                    let entry;
-                    if (e instanceof Entry) {
-                        entry = e;
+            }
+            /* await this.load({ reload: false }); */
+            const nexts = options.meta?.next ||
+                (await this.entryIndex
+                    .getHeads(undefined, { type: "shape", shape: Sorting.ENTRY_SORT_SHAPE })
+                    .all());
+            // Calculate max time for log/graph
+            const clock = new Clock({
+                id: this._identity.publicKey.bytes,
+                timestamp: options?.meta?.timestamp || this._hlc.now(),
+            });
+            const entry = await EntryV0.create({
+                store: this._storage,
+                identity: options.identity || this._identity,
+                signers: options.signers,
+                data,
+                meta: {
+                    clock,
+                    type: options.meta?.type,
+                    gidSeed: options.meta?.gidSeed,
+                    data: options.meta?.data,
+                    next: nexts,
+                },
+                encoding: this._encoding,
+                encryption: options.encryption
+                    ? {
+                        keypair: options.encryption.keypair,
+                        receiver: {
+                            ...options.encryption.receiver,
+                        },
                     }
-                    else {
-                        let resolved = await this.entryIndex.get(e.hash);
-                        if (!resolved) {
-                            // eslint-disable-next-line no-console
-                            console.warn("Unexpected missing entry when joining", e.hash);
-                            continue;
+                    : undefined,
+                canAppend: options.canAppend || this._canAppend,
+            });
+            if (!entry.hash) {
+                throw new Error("Unexpected");
+            }
+            if (entry.meta.type !== EntryType.CUT) {
+                for (const e of nexts) {
+                    if (!(await this.has(e.hash))) {
+                        let entry;
+                        if (e instanceof Entry) {
+                            entry = e;
+                        }
+                        else {
+                            let resolved = await this.entryIndex.get(e.hash);
+                            if (!resolved) {
+                                // eslint-disable-next-line no-console
+                                console.warn("Unexpected missing entry when joining", e.hash);
+                                continue;
+                            }
+                            entry = resolved;
                         }
-                        entry = resolved;
+                        await this.join([entry]);
                     }
-                    await this.join([entry]);
                 }
             }
-        }
-        await this.entryIndex.put(entry, {
-            unique: true,
-            isHead: true,
-            toMultiHash: false,
-        });
-        const pendingDeletes = await this.processEntry(entry);
-        entry.init({ encoding: this._encoding, keychain: this._keychain });
-        const trimmed = await this.trim(options?.trim);
-        if (trimmed) {
-            for (const entry of trimmed) {
-                pendingDeletes.push({ entry, fn: undefined });
-            }
-        }
-        const removed = pendingDeletes.map((x) => x.entry);
-        const changes = {
-            added: [{ head: true, entry }],
-            removed,
-        };
-        await (options?.onChange || this._onChange)?.(changes);
-        await Promise.all(pendingDeletes.map((x) => x.fn?.()));
-        return { entry, removed };
-    }
-    async remove(entry, options) {
-        /* await this.load({ reload: false }); */
-        const entries = Array.isArray(entry) ? entry : [entry];
-        if (entries.length === 0) {
-            return {
-                added: [],
-                removed: [],
+            await this.entryIndex.put(entry, {
+                unique: true,
+                isHead: true,
+                toMultiHash: false,
+            });
+            const pendingDeletes = await this.processEntry(entry);
+            entry.init({ encoding: this._encoding, keychain: this._keychain });
+            const trimmed = await this.trim(options?.trim);
+            if (trimmed) {
+                for (const entry of trimmed) {
+                    pendingDeletes.push({ entry, fn: undefined });
+                }
+            }
+            const removed = pendingDeletes.map((x) => x.entry);
+            const changes = {
+                added: [{ head: true, entry }],
+                removed,
             };
-        }
-        let removed;
-        if (options?.recursively) {
-            removed = await this.prepareDeleteRecursively(entry);
-        }
-        else {
-            removed = [];
-            for (const entry of entries) {
-                const deleteFn = await this.prepareDelete(entry.hash);
-                deleteFn.entry &&
-                    removed.push({ entry: deleteFn.entry, fn: deleteFn.fn });
-            }
-        }
-        const change = {
-            added: [],
-            removed: removed.map((x) => x.entry),
-        };
-        await this._onChange?.(change);
-        // invoke deletions
-        await Promise.all(removed.map((x) => x.fn()));
-        return change;
-    }
-    async trim(option = this._trim.options) {
-        return this._trim.trim(option);
-    }
-    async join(entriesOrLog, options) {
-        let entries;
-        let references = new Map();
-        if (entriesOrLog instanceof Log_1) {
-            if (entriesOrLog.entryIndex.length === 0)
-                return;
-            entries = await entriesOrLog.toArray();
-            for (const element of entries) {
-                references.set(element.hash, element);
+            await (options?.onChange || this._onChange)?.(changes);
+            await Promise.all(pendingDeletes.map((x) => x.fn?.()));
+            return { entry, removed };
+        }
+        async remove(entry, options) {
+            /* await this.load({ reload: false }); */
+            const entries = Array.isArray(entry) ? entry : [entry];
+            if (entries.length === 0) {
+                return {
+                    added: [],
+                    removed: [],
+                };
             }
-        }
-        else if (Array.isArray(entriesOrLog)) {
-            if (entriesOrLog.length === 0) {
-                return;
+            let removed;
+            if (options?.recursively) {
+                removed = await this.prepareDeleteRecursively(entry);
+            }
+            else {
+                removed = [];
+                for (const entry of entries) {
+                    const deleteFn = await this.prepareDelete(entry.hash);
+                    deleteFn.entry &&
+                        removed.push({ entry: deleteFn.entry, fn: deleteFn.fn });
+                }
             }
-            entries = [];
-            for (const element of entriesOrLog) {
-                if (element instanceof Entry) {
-                    entries.push(element);
+            const change = {
+                added: [],
+                removed: removed.map((x) => x.entry),
+            };
+            await this._onChange?.(change);
+            // invoke deletions
+            await Promise.all(removed.map((x) => x.fn()));
+            return change;
+        }
+        async trim(option = this._trim.options) {
+            return this._trim.trim(option);
+        }
+        async join(entriesOrLog, options) {
+            let entries;
+            let references = new Map();
+            if (entriesOrLog instanceof Log) {
+                if (entriesOrLog.entryIndex.length === 0)
+                    return;
+                entries = await entriesOrLog.toArray();
+                for (const element of entries) {
                     references.set(element.hash, element);
                 }
-                else if (typeof element === "string") {
-                    if ((await this.has(element)) && !options?.reset) {
-                        continue; // already in log
-                    }
-                    let entry = await Entry.fromMultihash(this._storage, element, {
-                        remote: {
-                            timeout: options?.timeout,
-                        },
-                    });
-                    if (!entry) {
-                        throw new Error("Missing entry in join by hash: " + element);
-                    }
-                    entries.push(entry);
+            }
+            else if (Array.isArray(entriesOrLog)) {
+                if (entriesOrLog.length === 0) {
+                    return;
                 }
-                else if (element instanceof ShallowEntry) {
-                    if ((await this.has(element.hash)) && !options?.reset) {
-                        continue; // already in log
+                entries = [];
+                for (const element of entriesOrLog) {
+                    if (element instanceof Entry) {
+                        entries.push(element);
+                        references.set(element.hash, element);
                     }
-                    let entry = await Entry.fromMultihash(this._storage, element.hash, {
-                        remote: {
-                            timeout: options?.timeout,
-                        },
-                    });
-                    if (!entry) {
-                        throw new Error("Missing entry in join by hash: " + element.hash);
+                    else if (typeof element === "string") {
+                        if ((await this.has(element)) && !options?.reset) {
+                            continue; // already in log
+                        }
+                        let entry = await Entry.fromMultihash(this._storage, element, {
+                            remote: {
+                                timeout: options?.timeout,
+                            },
+                        });
+                        if (!entry) {
+                            throw new Error("Missing entry in join by hash: " + element);
+                        }
+                        entries.push(entry);
                     }
-                    entries.push(entry);
-                }
-                else {
-                    entries.push(element.entry);
-                    references.set(element.entry.hash, element.entry);
-                    for (const ref of element.references) {
-                        references.set(ref.hash, ref);
+                    else if (element instanceof ShallowEntry) {
+                        if ((await this.has(element.hash)) && !options?.reset) {
+                            continue; // already in log
+                        }
+                        let entry = await Entry.fromMultihash(this._storage, element.hash, {
+                            remote: {
+                                timeout: options?.timeout,
+                            },
+                        });
+                        if (!entry) {
+                            throw new Error("Missing entry in join by hash: " + element.hash);
+                        }
+                        entries.push(entry);
+                    }
+                    else {
+                        entries.push(element.entry);
+                        references.set(element.entry.hash, element.entry);
+                        for (const ref of element.references) {
+                            references.set(ref.hash, ref);
+                        }
                     }
                 }
             }
-        }
-        else {
-            let all = await entriesOrLog.all(); // TODO dont load all at once
-            if (all.length === 0) {
-                return;
-            }
-            entries = all;
-        }
-        let heads = new Map();
-        for (const entry of entries) {
-            if (heads.has(entry.hash)) {
-                continue;
-            }
-            heads.set(entry.hash, true);
-            for (const next of await entry.getNext()) {
-                heads.set(next, false);
-            }
-        }
-        for (const entry of entries) {
-            let isHead = heads.get(entry.hash);
-            let prev = this._joining.get(entry.hash);
-            if (prev) {
-                await prev;
-            }
             else {
-                const p = this.joinRecursively(entry, {
-                    references,
-                    isHead,
-                    ...options,
-                });
-                this._joining.set(entry.hash, p);
-                p.finally(() => {
-                    this._joining.delete(entry.hash);
-                });
-                await p;
+                let all = await entriesOrLog.all(); // TODO dont load all at once
+                if (all.length === 0) {
+                    return;
+                }
+                entries = all;
             }
-        }
-    }
-    /**
-     * Bottom up join of entries into the log
-     * @param entry
-     * @param options
-     * @returns
-     */
-    async joinRecursively(entry, options) {
-        if (this.entryIndex.length > (options?.length ?? Number.MAX_SAFE_INTEGER)) {
-            return false;
-        }
-        if (!entry.hash) {
-            throw new Error("Unexpected");
-        }
-        if ((await this.has(entry.hash)) && !options.reset) {
-            return false;
-        }
-        entry.init(this);
-        if (options?.verifySignatures) {
-            if (!(await entry.verifySignatures())) {
-                throw new Error('Invalid signature entry with hash "' + entry.hash + '"');
-            }
-        }
-        const headsWithGid = await this.entryIndex
-            .getHeads(entry.meta.gid, { type: "shape", shape: ENTRY_JOIN_SHAPE })
-            .all();
-        if (headsWithGid) {
-            for (const v of headsWithGid) {
-                // TODO second argument should be a time compare instead? what about next nexts?
-                // and check the cut entry is newer than the current 'entry'
-                if (v.meta.type === EntryType.CUT &&
-                    v.meta.next.includes(entry.hash) &&
-                    Sorting.compare(entry, v, this._sortFn) < 0) {
-                    return false; // already deleted
+            let heads = new Map();
+            for (const entry of entries) {
+                if (heads.has(entry.hash)) {
+                    continue;
+                }
+                heads.set(entry.hash, true);
+                for (const next of await entry.getNext()) {
+                    heads.set(next, false);
                 }
             }
-        }
-        if (entry.meta.type !== EntryType.CUT) {
-            for (const a of entry.meta.next) {
-                const prev = this._joining.get(a);
+            for (const entry of entries) {
+                let isHead = heads.get(entry.hash);
+                let prev = this._joining.get(entry.hash);
                 if (prev) {
                     await prev;
                 }
-                else if (!(await this.has(a)) || options.reset) {
-                    const nested = options.references?.get(a) ||
-                        (await Entry.fromMultihash(this._storage, a, {
-                            remote: { timeout: options?.remote?.timeout },
-                        }));
-                    if (!nested) {
-                        throw new Error("Missing entry in joinRecursively: " + a);
-                    }
-                    const p = this.joinRecursively(nested, options.isHead ? { ...options, isHead: false } : options);
-                    this._joining.set(nested.hash, p);
+                else {
+                    const p = this.joinRecursively(entry, {
+                        references,
+                        isHead,
+                        ...options,
+                    });
+                    this._joining.set(entry.hash, p);
                     p.finally(() => {
-                        this._joining.delete(nested.hash);
+                        this._joining.delete(entry.hash);
                     });
                     await p;
                 }
             }
         }
-        if (this?._canAppend && !(await this?._canAppend(entry))) {
-            return false;
-        }
-        const clock = await entry.getClock();
-        this._hlc.update(clock.timestamp);
-        await this._entryIndex.put(entry, {
-            unique: false,
-            isHead: options.isHead,
-            toMultiHash: true,
-        });
-        const pendingDeletes = await this.processEntry(entry);
-        const trimmed = await this.trim(options?.trim);
-        if (trimmed) {
-            for (const entry of trimmed) {
-                pendingDeletes.push({ entry, fn: undefined });
-            }
-        }
-        const removed = pendingDeletes.map((x) => x.entry);
-        await options?.onChange?.({
-            added: [{ head: options.isHead, entry }],
-            removed: removed,
-        });
-        await this._onChange?.({
-            added: [{ head: options.isHead, entry }],
-            removed: removed,
-        });
-        await Promise.all(pendingDeletes.map((x) => x.fn?.()));
-        return true;
-    }
-    async processEntry(entry) {
-        if (entry.meta.type === EntryType.CUT) {
-            return this.prepareDeleteRecursively(entry, true);
-        }
-        return [];
-    }
-    async deleteRecursively(from, skipFirst = false) {
-        const toDelete = await this.prepareDeleteRecursively(from, skipFirst);
-        const promises = toDelete.map(async (x) => {
-            const removed = await x.fn();
-            if (removed) {
-                return removed;
-            }
-            return undefined;
-        });
-        const results = Promise.all(promises);
-        return (await results).filter((x) => x);
-    }
-    /// TODO simplify methods below
-    async prepareDeleteRecursively(from, skipFirst = false) {
-        const stack = Array.isArray(from) ? [...from] : [from];
-        const promises = [];
-        let counter = 0;
-        const toDelete = [];
-        while (stack.length > 0) {
-            const entry = stack.pop();
-            const skip = counter === 0 && skipFirst;
-            if (!skip) {
-                const deleteFn = await this.prepareDelete(entry.hash);
-                deleteFn.entry &&
-                    toDelete.push({ entry: deleteFn.entry, fn: deleteFn.fn });
-            }
-            for (const next of entry.meta.next) {
-                const nextFromNext = this.entryIndex.getHasNext(next);
-                const entriesThatHasNext = await nextFromNext.all();
-                // if there are no entries which is not of "CUT" type, we can safely delete the next entry
-                // figureately speaking, these means where are cutting all branches to a stem, so we can delete the stem as well
-                let hasAlternativeNext = !!entriesThatHasNext.find((x) => x.meta.type !== EntryType.CUT && x.hash !== entry.hash);
-                if (!hasAlternativeNext) {
-                    const ne = await this.get(next);
-                    if (ne) {
-                        stack.push(ne);
+        /**
+         * Bottom up join of entries into the log
+         * @param entry
+         * @param options
+         * @returns
+         */
+        async joinRecursively(entry, options) {
+            if (this.entryIndex.length > (options?.length ?? Number.MAX_SAFE_INTEGER)) {
+                return false;
+            }
+            if (!entry.hash) {
+                throw new Error("Unexpected");
+            }
+            if ((await this.has(entry.hash)) && !options.reset) {
+                return false;
+            }
+            entry.init(this);
+            if (options?.verifySignatures) {
+                if (!(await entry.verifySignatures())) {
+                    throw new Error('Invalid signature entry with hash "' + entry.hash + '"');
+                }
+            }
+            const headsWithGid = await this.entryIndex
+                .getHeads(entry.meta.gid, { type: "shape", shape: ENTRY_JOIN_SHAPE })
+                .all();
+            if (headsWithGid) {
+                for (const v of headsWithGid) {
+                    // TODO second argument should be a time compare instead? what about next nexts?
+                    // and check the cut entry is newer than the current 'entry'
+                    if (v.meta.type === EntryType.CUT &&
+                        v.meta.next.includes(entry.hash) &&
+                        Sorting.compare(entry, v, this._sortFn) < 0) {
+                        return false; // already deleted
                     }
                 }
             }
-            counter++;
-        }
-        await Promise.all(promises);
-        return toDelete;
-    }
-    async prepareDelete(hash) {
-        let entry = await this._entryIndex.getShallow(hash);
-        if (!entry) {
-            return { entry: undefined };
-        }
-        return {
-            entry: entry.value,
-            fn: async () => {
-                await this._trim.deleteFromCache(hash);
-                const removedEntry = (await this._entryIndex.delete(hash, entry.value));
-                return removedEntry;
-            },
-        };
-    }
-    async delete(hash) {
-        const deleteFn = await this.prepareDelete(hash);
-        return deleteFn.entry && deleteFn.fn();
-    }
-    /**
-     * Returns the log entries as a formatted string.
-     * @returns {string}
-     * @example
-     * two
-     * └─one
-     *   └─three
-     */
-    async toString(payloadMapper = (payload) => payload.getValue(this.encoding).toString()) {
-        return (await Promise.all((await this.toArray())
-            .slice()
-            .reverse()
-            .map(async (e, idx) => {
-            const parents = Entry.findDirectChildren(e, await this.toArray());
-            const len = parents.length;
-            let padding = new Array(Math.max(len - 1, 0));
-            padding = len > 1 ? padding.fill("  ") : padding;
-            padding = len > 0 ? padding.concat(["└─"]) : padding;
-            return (padding.join("") +
-                (payloadMapper?.(e.payload) || e.payload));
-        }))).join("\n");
-    }
-    async close() {
-        // Don't return early here if closed = true, because "load" might create processes that needs to be closed
-        this._closed = true; // closed = true before doing below, else we might try to open the headsIndex cache because it is closed as we assume log is still open
-        this._closeController.abort();
-        await this._indexer?.stop?.();
-        this._indexer = undefined;
-        this._loadedOnce = false;
-    }
-    async drop() {
-        // Don't return early here if closed = true, because "load" might create processes that needs to be closed
-        this._closed = true; // closed = true before doing below, else we might try to open the headsIndex cache because it is closed as we assume log is still open
-        this._closeController.abort();
-        await this.entryIndex?.clear();
-        await this._indexer?.drop();
-        await this._indexer?.stop?.();
-    }
-    async recover() {
-        // merge existing
-        const existing = await this.getHeads(true).all();
-        const allHeads = new Map();
-        for (const head of existing) {
-            allHeads.set(head.hash, head);
+            if (entry.meta.type !== EntryType.CUT) {
+                for (const a of entry.meta.next) {
+                    const prev = this._joining.get(a);
+                    if (prev) {
+                        await prev;
+                    }
+                    else if (!(await this.has(a)) || options.reset) {
+                        const nested = options.references?.get(a) ||
+                            (await Entry.fromMultihash(this._storage, a, {
+                                remote: { timeout: options?.remote?.timeout },
+                            }));
+                        if (!nested) {
+                            throw new Error("Missing entry in joinRecursively: " + a);
+                        }
+                        const p = this.joinRecursively(nested, options.isHead ? { ...options, isHead: false } : options);
+                        this._joining.set(nested.hash, p);
+                        p.finally(() => {
+                            this._joining.delete(nested.hash);
+                        });
+                        await p;
+                    }
+                }
+            }
+            if (this?._canAppend && !(await this?._canAppend(entry))) {
+                return false;
+            }
+            const clock = await entry.getClock();
+            this._hlc.update(clock.timestamp);
+            await this._entryIndex.put(entry, {
+                unique: false,
+                isHead: options.isHead,
+                toMultiHash: true,
+            });
+            const pendingDeletes = await this.processEntry(entry);
+            const trimmed = await this.trim(options?.trim);
+            if (trimmed) {
+                for (const entry of trimmed) {
+                    pendingDeletes.push({ entry, fn: undefined });
+                }
+            }
+            const removed = pendingDeletes.map((x) => x.entry);
+            await options?.onChange?.({
+                added: [{ head: options.isHead, entry }],
+                removed: removed,
+            });
+            await this._onChange?.({
+                added: [{ head: options.isHead, entry }],
+                removed: removed,
+            });
+            await Promise.all(pendingDeletes.map((x) => x.fn?.()));
+            return true;
         }
-        // fetch all possible entries
-        for await (const [key, value] of this._storage.iterator()) {
-            if (allHeads.has(key)) {
-                continue;
+        async processEntry(entry) {
+            if (entry.meta.type === EntryType.CUT) {
+                return this.prepareDeleteRecursively(entry, true);
             }
-            try {
-                cidifyString(key);
+            return [];
+        }
+        async deleteRecursively(from, skipFirst = false) {
+            const toDelete = await this.prepareDeleteRecursively(from, skipFirst);
+            const promises = toDelete.map(async (x) => {
+                const removed = await x.fn();
+                if (removed) {
+                    return removed;
+                }
+                return undefined;
+            });
+            const results = Promise.all(promises);
+            return (await results).filter((x) => x);
+        }
+        /// TODO simplify methods below
+        async prepareDeleteRecursively(from, skipFirst = false) {
+            const stack = Array.isArray(from) ? [...from] : [from];
+            const promises = [];
+            let counter = 0;
+            const toDelete = [];
+            while (stack.length > 0) {
+                const entry = stack.pop();
+                const skip = counter === 0 && skipFirst;
+                if (!skip) {
+                    const deleteFn = await this.prepareDelete(entry.hash);
+                    deleteFn.entry &&
+                        toDelete.push({ entry: deleteFn.entry, fn: deleteFn.fn });
+                }
+                for (const next of entry.meta.next) {
+                    const nextFromNext = this.entryIndex.getHasNext(next);
+                    const entriesThatHasNext = await nextFromNext.all();
+                    // if there are no entries which is not of "CUT" type, we can safely delete the next entry
+                    // figureately speaking, these means where are cutting all branches to a stem, so we can delete the stem as well
+                    let hasAlternativeNext = !!entriesThatHasNext.find((x) => x.meta.type !== EntryType.CUT && x.hash !== entry.hash);
+                    if (!hasAlternativeNext) {
+                        const ne = await this.get(next);
+                        if (ne) {
+                            stack.push(ne);
+                        }
+                    }
+                }
+                counter++;
             }
-            catch (error) {
-                continue;
+            await Promise.all(promises);
+            return toDelete;
+        }
+        async prepareDelete(hash) {
+            let entry = await this._entryIndex.getShallow(hash);
+            if (!entry) {
+                return { entry: undefined };
             }
-            try {
-                const der = deserialize(value, Entry);
-                der.hash = key;
-                der.init(this);
-                allHeads.set(key, der);
+            return {
+                entry: entry.value,
+                fn: async () => {
+                    await this._trim.deleteFromCache(hash);
+                    const removedEntry = (await this._entryIndex.delete(hash, entry.value));
+                    return removedEntry;
+                },
+            };
+        }
+        async delete(hash) {
+            const deleteFn = await this.prepareDelete(hash);
+            return deleteFn.entry && deleteFn.fn();
+        }
+        /**
+         * Returns the log entries as a formatted string.
+         * @returns {string}
+         * @example
+         * two
+         * └─one
+         *   └─three
+         */
+        async toString(payloadMapper = (payload) => payload.getValue(this.encoding).toString()) {
+            return (await Promise.all((await this.toArray())
+                .slice()
+                .reverse()
+                .map(async (e, idx) => {
+                const parents = Entry.findDirectChildren(e, await this.toArray());
+                const len = parents.length;
+                let padding = new Array(Math.max(len - 1, 0));
+                padding = len > 1 ? padding.fill("  ") : padding;
+                padding = len > 0 ? padding.concat(["└─"]) : padding;
+                return (padding.join("") +
+                    (payloadMapper?.(e.payload) || e.payload));
+            }))).join("\n");
+        }
+        async close() {
+            // Don't return early here if closed = true, because "load" might create processes that needs to be closed
+            this._closed = true; // closed = true before doing below, else we might try to open the headsIndex cache because it is closed as we assume log is still open
+            this._closeController.abort();
+            await this._indexer?.stop?.();
+            this._indexer = undefined;
+            this._loadedOnce = false;
+        }
+        async drop() {
+            // Don't return early here if closed = true, because "load" might create processes that needs to be closed
+            this._closed = true; // closed = true before doing below, else we might try to open the headsIndex cache because it is closed as we assume log is still open
+            this._closeController.abort();
+            await this.entryIndex?.clear();
+            await this._indexer?.drop();
+            await this._indexer?.stop?.();
+        }
+        async recover() {
+            // merge existing
+            const existing = await this.getHeads(true).all();
+            const allHeads = new Map();
+            for (const head of existing) {
+                allHeads.set(head.hash, head);
             }
-            catch (error) {
-                continue; // invalid entries
+            // fetch all possible entries
+            for await (const [key, value] of this._storage.iterator()) {
+                if (allHeads.has(key)) {
+                    continue;
+                }
+                try {
+                    cidifyString(key);
+                }
+                catch (error) {
+                    continue;
+                }
+                try {
+                    const der = deserialize(value, Entry);
+                    der.hash = key;
+                    der.init(this);
+                    allHeads.set(key, der);
+                }
+                catch (error) {
+                    continue; // invalid entries
+                }
             }
+            // assume they are valid, (let access control reject them if not)
+            await this.load({ reset: true, heads: [...allHeads.values()] });
         }
-        // assume they are valid, (let access control reject them if not)
-        await this.load({ reset: true, heads: [...allHeads.values()] });
-    }
-    async load(opts = {}) {
-        if (this.closed) {
-            throw new Error("Closed");
-        }
-        if (this._loadedOnce && !opts.reset) {
-            return;
-        }
-        this._loadedOnce = true;
-        const heads = opts.heads ??
-            (await this.entryIndex
-                .getHeads(undefined, {
-                type: "full",
-                signal: this._closeController.signal,
-                ignoreMissing: opts.ignoreMissing,
-                timeout: opts.timeout,
-            })
-                .all());
-        if (heads) {
-            // Load the log
-            await this.join(heads instanceof Entry ? [heads] : heads, {
-                timeout: opts?.fetchEntryTimeout,
-                reset: opts?.reset,
-            });
-            if (opts.heads) {
-                // remove all heads that are not in the provided heads
-                const allHeads = this.getHeads(false);
-                const allProvidedHeadsHashes = new Set(opts.heads.map((x) => x.hash));
-                while (!allHeads.done()) {
-                    let next = await allHeads.next(100);
-                    for (const head of next) {
-                        if (!allProvidedHeadsHashes.has(head.hash)) {
-                            await this.remove(head);
+        async load(opts = {}) {
+            if (this.closed) {
+                throw new Error("Closed");
+            }
+            if (this._loadedOnce && !opts.reset) {
+                return;
+            }
+            this._loadedOnce = true;
+            const heads = opts.heads ??
+                (await this.entryIndex
+                    .getHeads(undefined, {
+                    type: "full",
+                    signal: this._closeController.signal,
+                    ignoreMissing: opts.ignoreMissing,
+                    timeout: opts.timeout,
+                })
+                    .all());
+            if (heads) {
+                // Load the log
+                await this.join(heads instanceof Entry ? [heads] : heads, {
+                    timeout: opts?.fetchEntryTimeout,
+                    reset: opts?.reset,
+                });
+                if (opts.heads) {
+                    // remove all heads that are not in the provided heads
+                    const allHeads = this.getHeads(false);
+                    const allProvidedHeadsHashes = new Set(opts.heads.map((x) => x.hash));
+                    while (!allHeads.done()) {
+                        let next = await allHeads.next(100);
+                        for (const head of next) {
+                            if (!allProvidedHeadsHashes.has(head.hash)) {
+                                await this.remove(head);
+                            }
                         }
                     }
                 }
             }
         }
-    }
-    static async fromEntry(store, identity, entryOrHash, options = { id: randomBytes(32) }) {
-        const log = new Log_1(options.id && { id: options.id });
-        await log.open(store, identity, options);
-        await log.join(!Array.isArray(entryOrHash) ? [entryOrHash] : entryOrHash, {
-            timeout: options.timeout,
-            trim: options.trim,
-            verifySignatures: true,
-        });
-        return log;
-    }
-    /**
-     * Find heads from a collection of entries.
-     *
-     * Finds entries that are the heads of this collection,
-     * ie. entries that are not referenced by other entries.
-     *
-     * @param {Array<Entry<T>>} entries - Entries to search heads from
-     * @returns {Array<Entry<T>>}
-     */
-    static findHeads(entries) {
-        const indexReducer = (res, entry) => {
-            const addToResult = (e) => (res[e] = entry.hash);
-            entry.meta.next.forEach(addToResult);
-            return res;
-        };
-        const items = entries.reduce(indexReducer, {});
-        const exists = (e) => items[e.hash] === undefined;
-        return entries.filter(exists);
-    }
-    // Find entries that point to another entry that is not in the
-    // input array
-    static findTails(entries) {
-        // Reverse index { next -> entry }
-        const reverseIndex = {};
-        // Null index containing entries that have no parents (nexts)
-        const nullIndex = [];
-        // Hashes for all entries for quick lookups
-        const hashes = {};
-        // Hashes of all next entries
-        let nexts = [];
-        const addToIndex = (e) => {
-            if (e.meta.next.length === 0) {
-                nullIndex.push(e);
-            }
-            const addToReverseIndex = (a) => {
-                /* istanbul ignore else */
-                if (!reverseIndex[a])
-                    reverseIndex[a] = [];
-                reverseIndex[a].push(e);
+        static async fromEntry(store, identity, entryOrHash, options = { id: randomBytes(32) }) {
+            const log = new Log(options.id && { id: options.id });
+            await log.open(store, identity, options);
+            await log.join(!Array.isArray(entryOrHash) ? [entryOrHash] : entryOrHash, {
+                timeout: options.timeout,
+                trim: options.trim,
+                verifySignatures: true,
+            });
+            return log;
+        }
+        /**
+         * Find heads from a collection of entries.
+         *
+         * Finds entries that are the heads of this collection,
+         * ie. entries that are not referenced by other entries.
+         *
+         * @param {Array<Entry<T>>} entries - Entries to search heads from
+         * @returns {Array<Entry<T>>}
+         */
+        static findHeads(entries) {
+            const indexReducer = (res, entry) => {
+                const addToResult = (e) => (res[e] = entry.hash);
+                entry.meta.next.forEach(addToResult);
+                return res;
             };
-            // Add all entries and their parents to the reverse index
-            e.meta.next.forEach(addToReverseIndex);
-            // Get all next references
-            nexts = nexts.concat(e.meta.next);
-            // Get the hashes of input entries
-            hashes[e.hash] = true;
-        };
-        // Create our indices
-        entries.forEach(addToIndex);
-        const addUniques = (res, entries, _idx, _arr) => res.concat(findUniques(entries, "hash"));
-        const exists = (e) => hashes[e] === undefined;
-        const findFromReverseIndex = (e) => reverseIndex[e];
-        // Drop hashes that are not in the input entries
-        const tails = nexts // For every hash in nexts:
-            .filter(exists) // Remove undefineds and nulls
-            .map(findFromReverseIndex) // Get the Entry from the reverse index
-            .reduce(addUniques, []) // Flatten the result and take only uniques
-            .concat(nullIndex); // Combine with tails the have no next refs (ie. first-in-their-chain)
-        return findUniques(tails, "hash").sort(Entry.compare);
-    }
-    // Find the hashes to entries that are not in a collection
-    // but referenced by other entries
-    static findTailHashes(entries) {
-        const hashes = {};
-        const addToIndex = (e) => (hashes[e.hash] = true);
-        const reduceTailHashes = (res, entry, idx, arr) => {
-            const addToResult = (e) => {
-                /* istanbul ignore else */
-                if (hashes[e] === undefined) {
-                    res.splice(0, 0, e);
+            const items = entries.reduce(indexReducer, {});
+            const exists = (e) => items[e.hash] === undefined;
+            return entries.filter(exists);
+        }
+        // Find entries that point to another entry that is not in the
+        // input array
+        static findTails(entries) {
+            // Reverse index { next -> entry }
+            const reverseIndex = {};
+            // Null index containing entries that have no parents (nexts)
+            const nullIndex = [];
+            // Hashes for all entries for quick lookups
+            const hashes = {};
+            // Hashes of all next entries
+            let nexts = [];
+            const addToIndex = (e) => {
+                if (e.meta.next.length === 0) {
+                    nullIndex.push(e);
                 }
+                const addToReverseIndex = (a) => {
+                    /* istanbul ignore else */
+                    if (!reverseIndex[a])
+                        reverseIndex[a] = [];
+                    reverseIndex[a].push(e);
+                };
+                // Add all entries and their parents to the reverse index
+                e.meta.next.forEach(addToReverseIndex);
+                // Get all next references
+                nexts = nexts.concat(e.meta.next);
+                // Get the hashes of input entries
+                hashes[e.hash] = true;
             };
-            entry.meta.next.reverse().forEach(addToResult);
-            return res;
-        };
-        entries.forEach(addToIndex);
-        return entries.reduce(reduceTailHashes, []);
-    }
-};
-__decorate([
-    field({ type: fixedArray("u8", 32) }),
-    __metadata("design:type", Uint8Array)
-], Log.prototype, "_id", void 0);
-Log = Log_1 = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Object])
-], Log);
+            // Create our indices
+            entries.forEach(addToIndex);
+            const addUniques = (res, entries, _idx, _arr) => res.concat(findUniques(entries, "hash"));
+            const exists = (e) => hashes[e] === undefined;
+            const findFromReverseIndex = (e) => reverseIndex[e];
+            // Drop hashes that are not in the input entries
+            const tails = nexts // For every hash in nexts:
+                .filter(exists) // Remove undefineds and nulls
+                .map(findFromReverseIndex) // Get the Entry from the reverse index
+                .reduce(addUniques, []) // Flatten the result and take only uniques
+                .concat(nullIndex); // Combine with tails the have no next refs (ie. first-in-their-chain)
+            return findUniques(tails, "hash").sort(Entry.compare);
+        }
+        // Find the hashes to entries that are not in a collection
+        // but referenced by other entries
+        static findTailHashes(entries) {
+            const hashes = {};
+            const addToIndex = (e) => (hashes[e.hash] = true);
+            const reduceTailHashes = (res, entry, idx, arr) => {
+                const addToResult = (e) => {
+                    /* istanbul ignore else */
+                    if (hashes[e] === undefined) {
+                        res.splice(0, 0, e);
+                    }
+                };
+                entry.meta.next.reverse().forEach(addToResult);
+                return res;
+            };
+            entries.forEach(addToIndex);
+            return entries.reduce(reduceTailHashes, []);
+        }
+    };
+    return Log = _classThis;
+})();
 export { Log };
 //# sourceMappingURL=log.js.map