cojson-storage-indexeddb 0.5.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # cojson-storage-indexeddb
 
+## 0.6.1
+
+### Patch Changes
+
+- IndexedDB & timer perf improvements
+- Updated dependencies
+  - cojson@0.6.4
+
+## 0.6.0
+
+### Minor Changes
+
+- Make addMember and removeMember take loaded Accounts instead of just IDs
+
+### Patch Changes
+
+- Updated dependencies
+  - cojson@0.6.0
+
 ## 0.5.0
 
 ### Minor Changes

package/dist/index.js

@@ -1,6 +1,8 @@
 import { cojsonInternals, MAX_RECOMMENDED_TX_SIZE, } from "cojson";
+import { SyncPromise } from "./syncPromises";
 export class IDBStorage {
     constructor(db, fromLocalNode, toLocalNode) {
+        this.currentTxID = 0;
         this.db = db;
         this.fromLocalNode = fromLocalNode.getReader();
         this.toLocalNode = toLocalNode.getWriter();
@@ -10,12 +12,17 @@ export class IDBStorage {
                 const result = await this.fromLocalNode.read();
                 done = result.done;
                 if (result.value) {
-                    await this.handleSyncMessage(result.value);
                     // console.log(
                     //     "IDB: handling msg",
                     //     result.value.id,
                     //     result.value.action
                     // );
+                    await this.handleSyncMessage(result.value);
+                    // console.log(
+                    //     "IDB: handled msg",
+                    //     result.value.id,
+                    //     result.value.action
+                    // );
                 }
             }
         })();
@@ -63,19 +70,21 @@ export class IDBStorage {
                         keyPath: ["ses", "idx"],
                     });
                 }
-                if (ev.oldVersion !== 0 && ev.oldVersion <= 3) {
-                    // fix embarrassing off-by-one error for transaction indices
-                    console.log("Migration: fixing off-by-one error");
-                    const transaction = ev.target.transaction;
-                    const txsStore = transaction.objectStore("transactions");
-                    const txs = await promised(txsStore.getAll());
-                    for (const tx of txs) {
-                        await promised(txsStore.delete([tx.ses, tx.idx]));
-                        tx.idx -= 1;
-                        await promised(txsStore.add(tx));
-                    }
-                    console.log("Migration: fixing off-by-one error - done");
-                }
+                // if (ev.oldVersion !== 0 && ev.oldVersion <= 3) {
+                //     // fix embarrassing off-by-one error for transaction indices
+                //     console.log("Migration: fixing off-by-one error");
+                //     const transaction = (
+                //         ev.target as unknown as { transaction: IDBTransaction }
+                //     ).transaction;
+                //     const txsStore = transaction.objectStore("transactions");
+                //     const txs = await promised(txsStore.getAll());
+                //     for (const tx of txs) {
+                //         await promised(txsStore.delete([tx.ses, tx.idx]));
+                //         tx.idx -= 1;
+                //         await promised(txsStore.add(tx));
+                //     }
+                //     console.log("Migration: fixing off-by-one error - done");
+                // }
             };
         });
         return new IDBStorage(await dbPromise, fromLocalNode, toLocalNode);
@@ -83,253 +92,343 @@ export class IDBStorage {
     async handleSyncMessage(msg) {
         switch (msg.action) {
             case "load":
-                await this.handleLoad(msg);
+                /*await*/ this.handleLoad(msg);
                 break;
             case "content":
                 await this.handleContent(msg);
                 break;
             case "known":
-                await this.handleKnown(msg);
+                /*await*/ this.handleKnown(msg);
                 break;
             case "done":
-                await this.handleDone(msg);
+                /*await*/ this.handleDone(msg);
                 break;
         }
     }
-    async sendNewContentAfter(theirKnown, { coValues, sessions, transactions, signatureAfter, }, asDependencyOf) {
-        const coValueRow = await promised(coValues.index("coValuesById").get(theirKnown.id));
-        const allOurSessions = coValueRow
-            ? await promised(sessions.index("sessionsByCoValue").getAll(coValueRow.rowID))
-            : [];
-        const ourKnown = {
-            id: theirKnown.id,
-            header: !!coValueRow,
-            sessions: {},
-        };
-        const newContentPieces = [
-            {
-                action: "content",
-                id: theirKnown.id,
-                header: theirKnown.header ? undefined : coValueRow?.header,
-                new: {},
-            },
-        ];
-        for (const sessionRow of allOurSessions) {
-            ourKnown.sessions[sessionRow.sessionID] = sessionRow.lastIdx;
-            if (sessionRow.lastIdx >
-                (theirKnown.sessions[sessionRow.sessionID] || 0)) {
-                const firstNewTxIdx = theirKnown.sessions[sessionRow.sessionID] || 0;
-                const signaturesAndIdxs = await promised(signatureAfter.getAll(IDBKeyRange.bound([sessionRow.rowID, firstNewTxIdx], [sessionRow.rowID, Infinity])));
-                // console.log(
-                //     theirKnown.id,
-                //     "signaturesAndIdxs",
-                //     JSON.stringify(signaturesAndIdxs)
-                // );
-                const newTxInSession = await promised(transactions.getAll(IDBKeyRange.bound([sessionRow.rowID, firstNewTxIdx], [sessionRow.rowID, Infinity])));
-                let idx = firstNewTxIdx;
+    makeRequest(handler) {
+        return new SyncPromise((resolve, reject) => {
+            let txEntry = this.currentTx;
+            const requestEntry = ({ stores, }) => {
+                const request = handler(stores);
+                request.onerror = () => {
+                    console.error("Error in request", request.error);
+                    this.currentTx = undefined;
+                    reject(request.error);
+                    // TODO: recover pending requests in new tx
+                };
+                request.onsuccess = () => {
+                    const value = request.result;
+                    resolve(value);
+                    const next = txEntry.pendingRequests.shift();
+                    if (next) {
+                        next({ stores });
+                    }
+                    else {
+                        if (this.currentTx === txEntry) {
+                            this.currentTx = undefined;
+                        }
+                    }
+                };
+            };
+            if (!txEntry || performance.now() - txEntry.startedAt > 20) {
+                const tx = this.db.transaction(["coValues", "sessions", "transactions", "signatureAfter"], "readwrite");
+                txEntry = {
+                    id: this.currentTxID++,
+                    tx,
+                    stores: {
+                        coValues: tx.objectStore("coValues"),
+                        sessions: tx.objectStore("sessions"),
+                        transactions: tx.objectStore("transactions"),
+                        signatureAfter: tx.objectStore("signatureAfter"),
+                    },
+                    startedAt: performance.now(),
+                    pendingRequests: [],
+                };
+                console.time("IndexedDB TX" + txEntry.id);
+                txEntry.tx.oncomplete = () => {
+                    console.timeEnd("IndexedDB TX" + txEntry.id);
+                };
+                this.currentTx = txEntry;
+                requestEntry(txEntry);
+            }
+            else {
+                txEntry.pendingRequests.push(requestEntry);
                 // console.log(
-                //     theirKnown.id,
-                //     "newTxInSession",
-                //     newTxInSession.length
+                //     "Queued request in TX " + txEntry.id,
+                //     txEntry.pendingRequests.length
                 // );
-                for (const tx of newTxInSession) {
-                    let sessionEntry = newContentPieces[newContentPieces.length - 1].new[sessionRow.sessionID];
-                    if (!sessionEntry) {
-                        sessionEntry = {
-                            after: idx,
-                            lastSignature: "WILL_BE_REPLACED",
-                            newTransactions: [],
-                        };
-                        newContentPieces[newContentPieces.length - 1].new[sessionRow.sessionID] = sessionEntry;
-                    }
-                    sessionEntry.newTransactions.push(tx.tx);
-                    if (signaturesAndIdxs[0] &&
-                        idx === signaturesAndIdxs[0].idx) {
-                        sessionEntry.lastSignature =
-                            signaturesAndIdxs[0].signature;
-                        signaturesAndIdxs.shift();
-                        newContentPieces.push({
-                            action: "content",
-                            id: theirKnown.id,
-                            new: {},
+            }
+        });
+    }
+    sendNewContentAfter(theirKnown, asDependencyOf) {
+        return this.makeRequest(({ coValues }) => coValues.index("coValuesById").get(theirKnown.id))
+            .then((coValueRow) => {
+            return (coValueRow
+                ? this.makeRequest(({ sessions }) => sessions
+                    .index("sessionsByCoValue")
+                    .getAll(coValueRow.rowID))
+                : SyncPromise.resolve([])).then((allOurSessions) => {
+                const ourKnown = {
+                    id: theirKnown.id,
+                    header: !!coValueRow,
+                    sessions: {},
+                };
+                const newContentPieces = [
+                    {
+                        action: "content",
+                        id: theirKnown.id,
+                        header: theirKnown.header
+                            ? undefined
+                            : coValueRow?.header,
+                        new: {},
+                    },
+                ];
+                return SyncPromise.all(allOurSessions.map((sessionRow) => {
+                    ourKnown.sessions[sessionRow.sessionID] =
+                        sessionRow.lastIdx;
+                    if (sessionRow.lastIdx >
+                        (theirKnown.sessions[sessionRow.sessionID] || 0)) {
+                        const firstNewTxIdx = theirKnown.sessions[sessionRow.sessionID] ||
+                            0;
+                        return this.makeRequest(({ signatureAfter }) => signatureAfter.getAll(IDBKeyRange.bound([
+                            sessionRow.rowID,
+                            firstNewTxIdx,
+                        ], [sessionRow.rowID, Infinity]))).then((signaturesAndIdxs) => {
+                            // console.log(
+                            //     theirKnown.id,
+                            //     "signaturesAndIdxs",
+                            //     JSON.stringify(signaturesAndIdxs)
+                            // );
+                            return this.makeRequest(({ transactions }) => transactions.getAll(IDBKeyRange.bound([
+                                sessionRow.rowID,
+                                firstNewTxIdx,
+                            ], [sessionRow.rowID, Infinity]))).then((newTxsInSession) => {
+                                collectNewTxs(newTxsInSession, newContentPieces, sessionRow, signaturesAndIdxs, theirKnown, firstNewTxIdx);
+                            });
                         });
                     }
-                    else if (idx ===
-                        firstNewTxIdx + newTxInSession.length - 1) {
-                        sessionEntry.lastSignature = sessionRow.lastSignature;
+                    else {
+                        return SyncPromise.resolve();
                     }
-                    idx += 1;
-                }
-            }
-        }
-        const dependedOnCoValues = coValueRow?.header.ruleset.type === "group"
-            ? newContentPieces
-                .flatMap((piece) => Object.values(piece.new))
-                .flatMap((sessionEntry) => sessionEntry.newTransactions.flatMap((tx) => {
-                if (tx.privacy !== "trusting")
-                    return [];
-                // TODO: avoid parse here?
-                return cojsonInternals
-                    .parseJSON(tx.changes)
-                    .map((change) => change &&
-                    typeof change === "object" &&
-                    "op" in change &&
-                    change.op === "set" &&
-                    "key" in change &&
-                    change.key)
-                    .filter((key) => typeof key === "string" &&
-                    key.startsWith("co_"));
-            }))
-            : coValueRow?.header.ruleset.type === "ownedByGroup"
-                ? [
-                    coValueRow?.header.ruleset.group,
-                    ...new Set(newContentPieces.flatMap((piece) => Object.keys(piece)
-                        .map((sessionID) => cojsonInternals.accountOrAgentIDfromSessionID(sessionID))
-                        .filter((accountID) => cojsonInternals.isAccountID(accountID) && accountID !== theirKnown.id))),
-                ]
-                : [];
-        for (const dependedOnCoValue of dependedOnCoValues) {
-            await this.sendNewContentAfter({ id: dependedOnCoValue, header: false, sessions: {} }, { coValues, sessions, transactions, signatureAfter }, asDependencyOf || theirKnown.id);
-        }
-        await this.toLocalNode.write({
-            action: "known",
-            ...ourKnown,
-            asDependencyOf,
-        });
-        const nonEmptyNewContentPieces = newContentPieces.filter((piece) => piece.header || Object.keys(piece.new).length > 0);
-        // console.log(theirKnown.id, nonEmptyNewContentPieces);
-        for (const piece of nonEmptyNewContentPieces) {
-            await this.toLocalNode.write(piece);
-            await new Promise((resolve) => setTimeout(resolve, 0));
-        }
+                })).then(() => {
+                    const dependedOnCoValues = getDependedOnCoValues(coValueRow, newContentPieces, theirKnown);
+                    return SyncPromise.all(dependedOnCoValues.map((dependedOnCoValue) => this.sendNewContentAfter({
+                        id: dependedOnCoValue,
+                        header: false,
+                        sessions: {},
+                    }, asDependencyOf || theirKnown.id))).then(() => {
+                        // we're done with IndexedDB stuff here so can use native Promises again
+                        setTimeout(async () => {
+                            await this.toLocalNode.write({
+                                action: "known",
+                                ...ourKnown,
+                                asDependencyOf,
+                            });
+                            const nonEmptyNewContentPieces = newContentPieces.filter((piece) => piece.header ||
+                                Object.keys(piece.new).length > 0);
+                            // console.log(theirKnown.id, nonEmptyNewContentPieces);
+                            for (const piece of nonEmptyNewContentPieces) {
+                                await this.toLocalNode.write(piece);
+                                await new Promise((resolve) => setTimeout(resolve, 0));
+                            }
+                        }, 0);
+                        return Promise.resolve();
+                    });
+                });
+            });
+        })
+            .then(() => { });
     }
     handleLoad(msg) {
-        return this.sendNewContentAfter(msg, this.inTransaction("readonly"));
+        return this.sendNewContentAfter(msg);
     }
-    async handleContent(msg) {
-        const { coValues, sessions, transactions, signatureAfter } = this.inTransaction("readwrite");
-        let storedCoValueRowID = (await promised(coValues.index("coValuesById").get(msg.id)))?.rowID;
-        if (storedCoValueRowID === undefined) {
-            const header = msg.header;
-            if (!header) {
-                console.error("Expected to be sent header first");
-                await this.toLocalNode.write({
-                    action: "known",
+    handleContent(msg) {
+        return this.makeRequest(({ coValues }) => coValues.index("coValuesById").get(msg.id))
+            .then((coValueRow) => {
+            if (coValueRow?.rowID === undefined) {
+                const header = msg.header;
+                if (!header) {
+                    console.error("Expected to be sent header first");
+                    this.toLocalNode.write({
+                        action: "known",
+                        id: msg.id,
+                        header: false,
+                        sessions: {},
+                        isCorrection: true,
+                    });
+                    throw new Error("Expected to be sent header first");
+                }
+                return this.makeRequest(({ coValues }) => coValues.put({
                     id: msg.id,
-                    header: false,
-                    sessions: {},
-                    isCorrection: true,
-                });
-                return;
+                    header: header,
+                }));
             }
-            storedCoValueRowID = (await promised(coValues.put({
-                id: msg.id,
-                header: header,
-            })));
-        }
-        const allOurSessions = await new Promise((resolve) => {
-            const allOurSessionsRequest = sessions
+            else {
+                return SyncPromise.resolve(coValueRow.rowID);
+            }
+        })
+            .then((storedCoValueRowID) => {
+            this.makeRequest(({ sessions }) => sessions
                 .index("sessionsByCoValue")
-                .getAll(storedCoValueRowID);
-            allOurSessionsRequest.onsuccess = () => {
-                resolve(Object.fromEntries(allOurSessionsRequest.result.map((row) => [row.sessionID, row])));
-            };
+                .getAll(storedCoValueRowID)).then((allOurSessionsEntries) => {
+                const allOurSessions = Object.fromEntries(allOurSessionsEntries.map((row) => [row.sessionID, row]));
+                const ourKnown = {
+                    id: msg.id,
+                    header: true,
+                    sessions: {},
+                };
+                let invalidAssumptions = false;
+                return Promise.all(Object.keys(msg.new).map((sessionID) => {
+                    const sessionRow = allOurSessions[sessionID];
+                    if (sessionRow) {
+                        ourKnown.sessions[sessionRow.sessionID] =
+                            sessionRow.lastIdx;
+                    }
+                    if ((sessionRow?.lastIdx || 0) <
+                        (msg.new[sessionID]?.after || 0)) {
+                        invalidAssumptions = true;
+                    }
+                    else {
+                        return this.putNewTxs(msg, sessionID, sessionRow, storedCoValueRowID);
+                    }
+                })).then(() => {
+                    if (invalidAssumptions) {
+                        this.toLocalNode.write({
+                            action: "known",
+                            ...ourKnown,
+                            isCorrection: invalidAssumptions,
+                        });
+                    }
+                });
+            });
         });
-        const ourKnown = {
-            id: msg.id,
-            header: true,
-            sessions: {},
+    }
+    putNewTxs(msg, sessionID, sessionRow, storedCoValueRowID) {
+        const newTransactions = msg.new[sessionID]?.newTransactions || [];
+        const actuallyNewOffset = (sessionRow?.lastIdx || 0) - (msg.new[sessionID]?.after || 0);
+        const actuallyNewTransactions = newTransactions.slice(actuallyNewOffset);
+        let newBytesSinceLastSignature = (sessionRow?.bytesSinceLastSignature || 0) +
+            actuallyNewTransactions.reduce((sum, tx) => sum +
+                (tx.privacy === "private"
+                    ? tx.encryptedChanges.length
+                    : tx.changes.length), 0);
+        const newLastIdx = (sessionRow?.lastIdx || 0) + actuallyNewTransactions.length;
+        let shouldWriteSignature = false;
+        if (newBytesSinceLastSignature > MAX_RECOMMENDED_TX_SIZE) {
+            shouldWriteSignature = true;
+            newBytesSinceLastSignature = 0;
+        }
+        const nextIdx = sessionRow?.lastIdx || 0;
+        const sessionUpdate = {
+            coValue: storedCoValueRowID,
+            sessionID: sessionID,
+            lastIdx: newLastIdx,
+            lastSignature: msg.new[sessionID].lastSignature,
+            bytesSinceLastSignature: newBytesSinceLastSignature,
         };
-        let invalidAssumptions = false;
-        for (const sessionID of Object.keys(msg.new)) {
-            const sessionRow = allOurSessions[sessionID];
-            if (sessionRow) {
-                ourKnown.sessions[sessionRow.sessionID] = sessionRow.lastIdx;
+        return this.makeRequest(({ sessions }) => sessions.put(sessionRow?.rowID
+            ? {
+                rowID: sessionRow.rowID,
+                ...sessionUpdate,
             }
-            if ((sessionRow?.lastIdx || 0) < (msg.new[sessionID]?.after || 0)) {
-                invalidAssumptions = true;
+            : sessionUpdate)).then((sessionRowID) => {
+            let maybePutRequest;
+            if (shouldWriteSignature) {
+                maybePutRequest = this.makeRequest(({ signatureAfter }) => signatureAfter.put({
+                    ses: sessionRowID,
+                    // TODO: newLastIdx is a misnomer, it's actually more like nextIdx or length
+                    idx: newLastIdx - 1,
+                    signature: msg.new[sessionID].lastSignature,
+                }));
             }
             else {
-                const newTransactions = msg.new[sessionID]?.newTransactions || [];
-                const actuallyNewOffset = (sessionRow?.lastIdx || 0) -
-                    (msg.new[sessionID]?.after || 0);
-                const actuallyNewTransactions = newTransactions.slice(actuallyNewOffset);
-                let newBytesSinceLastSignature = (sessionRow?.bytesSinceLastSignature || 0) +
-                    actuallyNewTransactions.reduce((sum, tx) => sum +
-                        (tx.privacy === "private"
-                            ? tx.encryptedChanges.length
-                            : tx.changes.length), 0);
-                const newLastIdx = (sessionRow?.lastIdx || 0) + actuallyNewTransactions.length;
-                let shouldWriteSignature = false;
-                if (newBytesSinceLastSignature > MAX_RECOMMENDED_TX_SIZE) {
-                    shouldWriteSignature = true;
-                    newBytesSinceLastSignature = 0;
-                }
-                let nextIdx = sessionRow?.lastIdx || 0;
-                const sessionUpdate = {
-                    coValue: storedCoValueRowID,
-                    sessionID: sessionID,
-                    lastIdx: newLastIdx,
-                    lastSignature: msg.new[sessionID].lastSignature,
-                    bytesSinceLastSignature: newBytesSinceLastSignature,
-                };
-                const sessionRowID = (await promised(sessions.put(sessionRow?.rowID
-                    ? {
-                        rowID: sessionRow.rowID,
-                        ...sessionUpdate,
-                    }
-                    : sessionUpdate)));
-                if (shouldWriteSignature) {
-                    await promised(signatureAfter.put({
-                        ses: sessionRowID,
-                        // TODO: newLastIdx is a misnomer, it's actually more like nextIdx or length
-                        idx: newLastIdx - 1,
-                        signature: msg.new[sessionID].lastSignature,
-                    }));
-                }
-                for (const newTransaction of actuallyNewTransactions) {
-                    await promised(transactions.add({
-                        ses: sessionRowID,
-                        idx: nextIdx,
-                        tx: newTransaction,
-                    }));
-                    nextIdx++;
-                }
+                maybePutRequest = SyncPromise.resolve();
             }
-        }
-        if (invalidAssumptions) {
-            await this.toLocalNode.write({
-                action: "known",
-                ...ourKnown,
-                isCorrection: invalidAssumptions,
-            });
-        }
+            return maybePutRequest.then(() => Promise.all(actuallyNewTransactions.map((newTransaction, i) => {
+                return this.makeRequest(({ transactions }) => transactions.add({
+                    ses: sessionRowID,
+                    idx: nextIdx + i,
+                    tx: newTransaction,
+                }));
+            })));
+        });
     }
     handleKnown(msg) {
-        return this.sendNewContentAfter(msg, this.inTransaction("readonly"));
+        return this.sendNewContentAfter(msg);
     }
     handleDone(_msg) { }
-    inTransaction(mode) {
-        const tx = this.db.transaction(["coValues", "sessions", "transactions", "signatureAfter"], mode);
-        tx.onerror = (event) => {
-            const target = event.target;
-            throw new Error(`Error in transaction (${target?.source?.name}): ${target?.error}`, { cause: target?.error });
-        };
-        const coValues = tx.objectStore("coValues");
-        const sessions = tx.objectStore("sessions");
-        const transactions = tx.objectStore("transactions");
-        const signatureAfter = tx.objectStore("signatureAfter");
-        return { coValues, sessions, transactions, signatureAfter };
+}
+function collectNewTxs(newTxsInSession, newContentPieces, sessionRow, signaturesAndIdxs, theirKnown, firstNewTxIdx) {
+    let idx = firstNewTxIdx;
+    // console.log(
+    //     theirKnown.id,
+    //     "newTxInSession",
+    //     newTxInSession.length
+    // );
+    for (const tx of newTxsInSession) {
+        let sessionEntry = newContentPieces[newContentPieces.length - 1].new[sessionRow.sessionID];
+        if (!sessionEntry) {
+            sessionEntry = {
+                after: idx,
+                lastSignature: "WILL_BE_REPLACED",
+                newTransactions: [],
+            };
+            newContentPieces[newContentPieces.length - 1].new[sessionRow.sessionID] = sessionEntry;
+        }
+        sessionEntry.newTransactions.push(tx.tx);
+        if (signaturesAndIdxs[0] && idx === signaturesAndIdxs[0].idx) {
+            sessionEntry.lastSignature = signaturesAndIdxs[0].signature;
+            signaturesAndIdxs.shift();
+            newContentPieces.push({
+                action: "content",
+                id: theirKnown.id,
+                new: {},
+            });
+        }
+        else if (idx === firstNewTxIdx + newTxsInSession.length - 1) {
+            sessionEntry.lastSignature = sessionRow.lastSignature;
+        }
+        idx += 1;
     }
 }
-function promised(request) {
-    return new Promise((resolve, reject) => {
-        request.onsuccess = () => {
-            resolve(request.result);
-        };
-        request.onerror = () => {
-            reject(request.error);
-        };
-    });
+function getDependedOnCoValues(coValueRow, newContentPieces, theirKnown) {
+    return coValueRow?.header.ruleset.type === "group"
+        ? newContentPieces
+            .flatMap((piece) => Object.values(piece.new))
+            .flatMap((sessionEntry) => sessionEntry.newTransactions.flatMap((tx) => {
+            if (tx.privacy !== "trusting")
+                return [];
+            // TODO: avoid parse here?
+            return cojsonInternals
+                .parseJSON(tx.changes)
+                .map((change) => change &&
+                typeof change === "object" &&
+                "op" in change &&
+                change.op === "set" &&
+                "key" in change &&
+                change.key)
+                .filter((key) => typeof key === "string" &&
+                key.startsWith("co_"));
+        }))
+        : coValueRow?.header.ruleset.type === "ownedByGroup"
+            ? [
+                coValueRow?.header.ruleset.group,
+                ...new Set(newContentPieces.flatMap((piece) => Object.keys(piece)
+                    .map((sessionID) => cojsonInternals.accountOrAgentIDfromSessionID(sessionID))
+                    .filter((accountID) => cojsonInternals.isAccountID(accountID) &&
+                    accountID !== theirKnown.id))),
+            ]
+            : [];
 }
+// let lastTx = 0;
+// function promised<T>(request: IDBRequest<T>): Promise<T> {
+//     return new Promise<T>((resolve, reject) => {
+//         request.onsuccess = () => {
+//             resolve(request.result);
+//         };
+//         request.onerror = () => {
+//             reject(request.error);
+//         };
+//     });
+// }
 //# sourceMappingURL=index.js.map