@agentshouse/mdruntime 0.1.0-c5d3fa6fb67bc → 0.1.0-c6636685d0c4b

package/dist/store.js

@@ -1,5 +1,7 @@
 import { sameBinary, sameChange } from './overlay.js';
-import { differing } from './shared.js';
+import { differences } from './shared.js';
+import { inUnits, ROW_WEIGHT, stepped } from './turn.js';
+import { precedes } from './windows.js';
 const DATABASE = 'mdruntime';
 const AUTHORED = 'mdruntime-authored';
 const FENCES = 'fences';
@@ -16,6 +18,7 @@ const PRESENTATION = 'presentation';
 const CONVERSATIONS = 'conversations';
 const MESSAGES = 'messages';
 const CHAT_DRAFTS = 'chatDrafts';
+const CALLS = 'calls';
 const QUEUES = 'queues';
 const FACTS = 'facts';
 const CURRENT = 'current';
@@ -26,12 +29,13 @@ const HOLDER = 'holder';
 const BINDING = 'binding';
 export const STORE_SCHEMA = 25;
 const REPLICA_SHAPE = 23;
-export const AUTHORED_SCHEMA = 2;
+export const AUTHORED_SCHEMA = 3;
 const AUTHORED_STORES = [
     [QUEUES, { keyPath: 'locator' }],
     [PENDING_CHANGES, { keyPath: ['locator', 'id'] }],
     [ROOM_DRAFTS, { keyPath: ['locator', 'path'] }],
     [CHAT_DRAFTS, { keyPath: 'conversation' }],
+    [CALLS, { keyPath: 'operation' }],
     [FACTS, undefined],
     [FENCES, { keyPath: 'locator' }],
 ];
@@ -59,11 +63,52 @@ function settled(request) {
         request.onerror = () => reject(request.error);
     });
 }
-function completed(transaction) {
-    return new Promise((resolve, reject) => {
-        transaction.oncomplete = () => resolve();
-        transaction.onerror = () => reject(transaction.error);
-        transaction.onabort = () => reject(transaction.error);
+const turns = new Map();
+function idle(database) {
+    return turns.get(database.name) ?? Promise.resolve();
+}
+export function transacted(database, stores, mode, work) {
+    let release = () => { };
+    const turn = new Promise((resolve) => {
+        release = resolve;
+    });
+    const before = idle(database);
+    const queued = before.then(() => turn);
+    turns.set(database.name, queued);
+    void queued.then(() => {
+        if (turns.get(database.name) === queued)
+            turns.delete(database.name);
+    });
+    return before.then(() => {
+        let transaction;
+        try {
+            transaction = database.transaction(stores, mode);
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
+        const committed = new Promise((resolve, reject) => {
+            transaction.oncomplete = () => {
+                release();
+                resolve();
+            };
+            transaction.onabort = () => {
+                release();
+                reject(transaction.error);
+            };
+            transaction.onerror = () => reject(transaction.error);
+        });
+        let value;
+        try {
+            value = work(transaction);
+        }
+        catch (error) {
+            void committed.catch(() => { });
+            transaction.abort();
+            throw error;
+        }
+        return Promise.all([value, committed]).then(([held]) => held);
     });
 }
 const EMPTY_DECLARATIONS = {
@@ -72,28 +117,27 @@ const EMPTY_DECLARATIONS = {
     capabilities: [],
 };
 function declaration(database) {
-    const transaction = database.transaction(DECLARATIONS, 'readonly');
-    return settled(transaction.objectStore(DECLARATIONS).get(CURRENT)).then((record) => record ?? EMPTY_DECLARATIONS);
+    return transacted(database, DECLARATIONS, 'readonly', (transaction) => settled(transaction.objectStore(DECLARATIONS).get(CURRENT))).then((record) => record ?? EMPTY_DECLARATIONS);
 }
 function updateDeclaration(database, update) {
-    const transaction = database.transaction(DECLARATIONS, 'readwrite');
-    const store = transaction.objectStore(DECLARATIONS);
-    const prior = store.get(CURRENT);
-    prior.onsuccess = () => {
-        store.put(update(prior.result ?? EMPTY_DECLARATIONS), CURRENT);
-    };
-    return completed(transaction);
+    return transacted(database, DECLARATIONS, 'readwrite', (transaction) => {
+        const store = transaction.objectStore(DECLARATIONS);
+        const prior = store.get(CURRENT);
+        prior.onsuccess = () => {
+            store.put(update(prior.result ?? EMPTY_DECLARATIONS), CURRENT);
+        };
+    });
 }
 function amendPending(database, locator, id, amendment) {
-    const transaction = database.transaction(PENDING_CHANGES, 'readwrite');
-    const pending = transaction.objectStore(PENDING_CHANGES);
-    const request = pending.get([locator, id]);
-    request.onsuccess = () => {
-        const record = request.result;
-        if (record !== undefined)
-            pending.put({ ...record, ...amendment });
-    };
-    return completed(transaction);
+    return transacted(database, PENDING_CHANGES, 'readwrite', (transaction) => {
+        const pending = transaction.objectStore(PENDING_CHANGES);
+        const request = pending.get([locator, id]);
+        request.onsuccess = () => {
+            const record = request.result;
+            if (record !== undefined)
+                pending.put({ ...record, ...amendment });
+        };
+    });
 }
 function accepted({ conversation: _held, ...message }) {
     return message;
@@ -172,33 +216,44 @@ function binaryFileRecord(locator, transfer, layer, path) {
         binary: layer.binaries[path],
     };
 }
-function writeLayer(transaction, locator, transfer, next, base) {
+function* changedIn(next, base) {
+    if (base === null)
+        return new Set([...Object.keys(next.documents), ...Object.keys(next.binaries)]);
+    return new Set([
+        ...(yield* differences(base.documents, next.documents)),
+        ...(yield* differences(base.revisions, next.revisions)),
+        ...(yield* differences(base.fileIds, next.fileIds)),
+        ...(yield* differences(base.written, next.written)),
+        ...(yield* differences(base.changes, next.changes, sameChange)),
+        ...(yield* differences(base.binaries, next.binaries, sameBinary)),
+    ]);
+}
+function writeLayer(transaction, locator, transfer, layer) {
+    const { next, base, paths } = layer;
     const documents = transaction.objectStore(DOCUMENTS);
     const files = transaction.objectStore(BINARY_FILES);
-    const paths = base === null
-        ? new Set([...Object.keys(next.documents), ...Object.keys(next.binaries)])
-        : new Set([
-            ...differing(base.documents, next.documents),
-            ...differing(base.revisions, next.revisions),
-            ...differing(base.fileIds, next.fileIds),
-            ...differing(base.written, next.written),
-            ...differing(base.changes, next.changes, sameChange),
-            ...differing(base.binaries, next.binaries, sameBinary),
-        ]);
-    for (const path of paths) {
+    let last = null;
+    return inUnits(paths, (path) => {
         if (next.documents[path] !== undefined) {
-            documents.put(documentRecord(locator, transfer, next, path));
+            last = documents.put(documentRecord(locator, transfer, next, path));
         }
         else if (base?.documents[path] !== undefined) {
-            documents.delete([locator, transfer, path]);
+            last = documents.delete([locator, transfer, path]);
         }
         if (next.binaries[path] !== undefined) {
-            files.put(binaryFileRecord(locator, transfer, next, path));
+            last = files.put(binaryFileRecord(locator, transfer, next, path));
         }
         else if (base?.binaries[path] !== undefined) {
-            files.delete([locator, transfer, path]);
+            last = files.delete([locator, transfer, path]);
         }
-    }
+        return ROW_WEIGHT + (next.documents[path]?.length ?? 0);
+    }, () => { }, () => {
+        const request = last;
+        last = null;
+        return request === null
+            ? Promise.resolve()
+            : new Promise((resolve) => request.addEventListener('success', () => resolve()));
+    });
 }
 function removeRoomEntries(store, locator) {
     const keys = store.getAllKeys();
@@ -219,10 +274,8 @@ function removeDatabase(name) {
 export async function authoredHolder() {
     const authored = await openAuthored();
     try {
-        const transaction = authored.transaction(FACTS, 'readonly');
-        const held = transaction.objectStore(FACTS).get(HOLDER);
-        await completed(transaction);
-        return typeof held.result === 'string' ? held.result : null;
+        const held = await transacted(authored, FACTS, 'readonly', (transaction) => settled(transaction.objectStore(FACTS).get(HOLDER)));
+        return typeof held === 'string' ? held : null;
     }
     finally {
         authored.close();
@@ -231,17 +284,17 @@ export async function authoredHolder() {
 export async function authoredBy(holder) {
     const authored = await openAuthored();
     try {
-        const transaction = authored.transaction(FACTS, 'readwrite');
-        const facts = transaction.objectStore(FACTS);
-        const held = facts.get(HOLDER);
         let owned = true;
-        held.onsuccess = () => {
-            if (held.result === undefined)
-                facts.put(holder, HOLDER);
-            else
-                owned = held.result === holder;
-        };
-        await completed(transaction);
+        await transacted(authored, FACTS, 'readwrite', (transaction) => {
+            const facts = transaction.objectStore(FACTS);
+            const held = facts.get(HOLDER);
+            held.onsuccess = () => {
+                if (held.result === undefined)
+                    facts.put(holder, HOLDER);
+                else
+                    owned = held.result === holder;
+            };
+        });
         return owned;
     }
     finally {
@@ -251,10 +304,8 @@ export async function authoredBy(holder) {
 export async function authoredBinding() {
     const authored = await openAuthored();
     try {
-        const transaction = authored.transaction(FACTS, 'readonly');
-        const held = transaction.objectStore(FACTS).get(BINDING);
-        await completed(transaction);
-        return typeof held.result === 'string' ? held.result : null;
+        const held = await transacted(authored, FACTS, 'readonly', (transaction) => settled(transaction.objectStore(FACTS).get(BINDING)));
+        return typeof held === 'string' ? held : null;
     }
     finally {
         authored.close();
@@ -263,9 +314,9 @@ export async function authoredBinding() {
 export async function bindAuthored(binding) {
     const authored = await openAuthored();
     try {
-        const transaction = authored.transaction(FACTS, 'readwrite');
-        transaction.objectStore(FACTS).put(binding, BINDING);
-        await completed(transaction);
+        await transacted(authored, FACTS, 'readwrite', (transaction) => {
+            transaction.objectStore(FACTS).put(binding, BINDING);
+        });
     }
     finally {
         authored.close();
@@ -329,79 +380,97 @@ export async function openRuntimeStore(fenced) {
         throw error;
     });
     return {
-        async all() {
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_FILES], 'readonly');
-            const rooms = await settled(transaction.objectStore(ROOMS).getAll());
-            const records = [];
-            for (const room of rooms.filter((held) => !fenced(held.locator))) {
-                records.push({ ...room, ...(await readLayer(transaction, room.locator, room.transfer)) });
-            }
-            return records;
+        all() {
+            return transacted(database, [ROOMS, DOCUMENTS, BINARY_FILES], 'readonly', async (transaction) => {
+                const rooms = await settled(transaction.objectStore(ROOMS).getAll());
+                const records = [];
+                for (const room of rooms.filter((held) => !fenced(held.locator))) {
+                    records.push({
+                        ...room,
+                        ...(await readLayer(transaction, room.locator, room.transfer)),
+                    });
+                }
+                return records;
+            });
         },
-        async keepAuthored({ locator, queue, saved, roomDrafts, consumedRoomDrafts }) {
+        async keepAuthored({ locator, queue, founded, saved, roomDrafts, consumedRoomDrafts }) {
             if (fenced(locator))
                 return;
-            const transaction = authored.transaction([QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
-            const order = transaction.objectStore(QUEUES);
-            const pending = transaction.objectStore(PENDING_CHANGES);
-            const held = order.get(locator);
-            held.onsuccess = () => {
-                const before = new Set(held.result?.order ?? []);
-                const after = new Set(queue.map((batch) => batch.id));
-                if (queue.length === 0)
-                    order.delete(locator);
-                else
-                    order.put({ locator, order: [...after] });
-                for (const id of before) {
-                    if (!after.has(id))
-                        pending.delete([locator, id]);
-                }
-                for (const batch of queue) {
-                    if (!before.has(batch.id)) {
-                        pending.put({
-                            locator,
-                            id: batch.id,
-                            batch,
-                            drafts: saved?.get(batch.id) ?? [],
-                            submission: { state: 'waiting' },
-                            lost: false,
-                        });
+            await transacted(authored, [QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite', (transaction) => {
+                const order = transaction.objectStore(QUEUES);
+                const pending = transaction.objectStore(PENDING_CHANGES);
+                const held = order.get(locator);
+                held.onsuccess = () => {
+                    const before = new Set(held.result?.order ?? []);
+                    const after = new Set(queue.map((batch) => batch.id));
+                    if (queue.length === 0)
+                        order.delete(locator);
+                    else
+                        order.put({ locator, order: [...after] });
+                    for (const id of before) {
+                        if (!after.has(id))
+                            pending.delete([locator, id]);
                     }
-                }
-            };
-            const draftStore = transaction.objectStore(ROOM_DRAFTS);
-            for (const path of consumedRoomDrafts ?? [])
-                draftStore.delete([locator, path]);
-            for (const record of roomDrafts ?? [])
-                draftStore.put(record);
-            await completed(transaction);
+                    for (const batch of queue) {
+                        if (!before.has(batch.id)) {
+                            pending.put({
+                                locator,
+                                id: batch.id,
+                                batch,
+                                drafts: saved?.get(batch.id) ?? [],
+                                submission: { state: 'waiting' },
+                                lost: false,
+                            });
+                        }
+                    }
+                    for (const batch of founded ?? []) {
+                        if (!before.has(batch.id))
+                            continue;
+                        const stored = pending.get([locator, batch.id]);
+                        stored.onsuccess = () => {
+                            const record = stored.result;
+                            if (record !== undefined)
+                                pending.put({ ...record, batch });
+                        };
+                    }
+                };
+                const draftStore = transaction.objectStore(ROOM_DRAFTS);
+                for (const path of consumedRoomDrafts ?? [])
+                    draftStore.delete([locator, path]);
+                for (const record of roomDrafts ?? [])
+                    draftStore.put(record);
+            });
         },
         async write({ next, previous, stored }) {
             if (next === previous || fenced(next.locator))
                 return;
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_FILES, TRANSFERS], 'readwrite');
-            transaction.objectStore(ROOMS).put(roomRecord(next));
             const moved = previous?.transfer !== next.transfer;
-            if (moved && previous !== null) {
-                const range = underTransfer(previous.locator, previous.transfer);
-                transaction.objectStore(DOCUMENTS).delete(range);
-                transaction.objectStore(BINARY_FILES).delete(range);
-            }
-            if (moved)
-                transaction.objectStore(TRANSFERS).delete(next.locator);
-            writeLayer(transaction, next.locator, next.transfer, next, moved ? (stored ?? null) : previous);
-            await completed(transaction);
+            const base = moved ? (stored ?? null) : previous;
+            const paths = await stepped(changedIn(next, base));
+            if (fenced(next.locator))
+                return;
+            await transacted(database, [ROOMS, DOCUMENTS, BINARY_FILES, TRANSFERS], 'readwrite', (transaction) => {
+                transaction.objectStore(ROOMS).put(roomRecord(next));
+                if (moved && previous !== null) {
+                    const range = underTransfer(previous.locator, previous.transfer);
+                    transaction.objectStore(DOCUMENTS).delete(range);
+                    transaction.objectStore(BINARY_FILES).delete(range);
+                }
+                if (moved)
+                    transaction.objectStore(TRANSFERS).delete(next.locator);
+                return writeLayer(transaction, next.locator, next.transfer, { next, base, paths });
+            });
         },
         async revokeModels(records) {
-            const transaction = database.transaction(ROOMS, 'readwrite');
-            const rooms = transaction.objectStore(ROOMS);
-            const revoked = { status: 'unavailable', reason: 'revoked' };
-            for (const record of records) {
-                if (fenced(record.locator))
-                    continue;
-                rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }));
-            }
-            await completed(transaction);
+            await transacted(database, ROOMS, 'readwrite', (transaction) => {
+                const rooms = transaction.objectStore(ROOMS);
+                const revoked = { status: 'unavailable', reason: 'revoked' };
+                for (const record of records) {
+                    if (fenced(record.locator))
+                        continue;
+                    rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }));
+                }
+            });
         },
         async lastCompleted() {
             return (await declaration(database)).lastCompleted;
@@ -423,31 +492,28 @@ export async function openRuntimeStore(fenced) {
             }));
         },
         async member() {
-            const transaction = database.transaction(DECLARATIONS, 'readonly');
-            const held = await settled(transaction.objectStore(DECLARATIONS).get(MEMBER));
+            const held = await transacted(database, DECLARATIONS, 'readonly', (transaction) => settled(transaction.objectStore(DECLARATIONS).get(MEMBER)));
             return held ?? null;
         },
         async keepMember(member) {
-            const transaction = database.transaction(DECLARATIONS, 'readwrite');
-            transaction.objectStore(DECLARATIONS).put(member, MEMBER);
-            await completed(transaction);
+            await transacted(database, DECLARATIONS, 'readwrite', (transaction) => {
+                transaction.objectStore(DECLARATIONS).put(member, MEMBER);
+            });
         },
         async targets() {
-            const transaction = database.transaction(DECLARATIONS, 'readonly');
-            const held = await settled(transaction.objectStore(DECLARATIONS).get(TARGETS));
+            const held = await transacted(database, DECLARATIONS, 'readonly', (transaction) => settled(transaction.objectStore(DECLARATIONS).get(TARGETS)));
             return held ?? {};
         },
         async keepTargets(targets) {
-            const transaction = database.transaction(DECLARATIONS, 'readwrite');
-            transaction.objectStore(DECLARATIONS).put(targets, TARGETS);
-            await completed(transaction);
+            await transacted(database, DECLARATIONS, 'readwrite', (transaction) => {
+                transaction.objectStore(DECLARATIONS).put(targets, TARGETS);
+            });
         },
         async queues() {
-            const transaction = authored.transaction([QUEUES, PENDING_CHANGES], 'readonly');
-            const [queues, pending] = await Promise.all([
+            const [queues, pending] = await transacted(authored, [QUEUES, PENDING_CHANGES], 'readonly', (transaction) => Promise.all([
                 settled(transaction.objectStore(QUEUES).getAll()),
                 settled(transaction.objectStore(PENDING_CHANGES).getAll()),
-            ]);
+            ]));
             const byId = new Map(pending.map((record) => [`${record.locator}\0${record.id}`, record]));
             return queues
                 .filter((queue) => !fenced(queue.locator))
@@ -475,260 +541,276 @@ export async function openRuntimeStore(fenced) {
                 await amendPending(authored, locator, id, { upload });
         },
         async roomDrafts() {
-            const transaction = authored.transaction(ROOM_DRAFTS, 'readonly');
-            const held = await settled(transaction.objectStore(ROOM_DRAFTS).getAll());
+            const held = await transacted(authored, ROOM_DRAFTS, 'readonly', (transaction) => settled(transaction.objectStore(ROOM_DRAFTS).getAll()));
             return held.filter((record) => !fenced(record.locator));
         },
-        async presentation() {
-            const transaction = database.transaction(PRESENTATION, 'readonly');
-            return settled(transaction.objectStore(PRESENTATION).getAll());
+        presentation() {
+            return transacted(database, PRESENTATION, 'readonly', (transaction) => settled(transaction.objectStore(PRESENTATION).getAll()));
         },
         async present(record) {
-            const transaction = database.transaction(PRESENTATION, 'readwrite');
-            transaction.objectStore(PRESENTATION).put(record);
-            await completed(transaction);
-        },
-        async conversations() {
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES], 'readonly');
-            const records = await settled(transaction.objectStore(CONVERSATIONS).getAll());
-            const held = new Map(records.map(({ conversation, read, partial }) => [
-                conversation,
-                { conversation, read, partial: partial === true },
-            ]));
-            const keys = transaction.objectStore(MESSAGES).index('conversation');
-            await new Promise((resolve, reject) => {
-                const cursor = keys.openKeyCursor(null, 'nextunique');
-                cursor.onerror = () => reject(cursor.error);
-                cursor.onsuccess = () => {
-                    const at = cursor.result;
-                    if (at === null) {
-                        resolve();
-                        return;
-                    }
-                    const conversation = at.key;
-                    if (!held.has(conversation)) {
-                        held.set(conversation, { conversation, read: undefined, partial: true });
-                    }
-                    at.continue();
-                };
+            await transacted(database, PRESENTATION, 'readwrite', (transaction) => {
+                transaction.objectStore(PRESENTATION).put(record);
             });
-            return [...held.values()];
         },
-        async keepMessages({ conversation, messages, read }) {
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES], 'readwrite');
-            const stored = transaction.objectStore(MESSAGES);
-            for (const message of messages) {
-                stored.put({ ...message, conversation });
-            }
-            if (read !== undefined) {
-                transaction.objectStore(CONVERSATIONS).put({
+        conversations() {
+            return transacted(database, [CONVERSATIONS, MESSAGES], 'readonly', async (transaction) => {
+                const records = await settled(transaction.objectStore(CONVERSATIONS).getAll());
+                const held = new Map(records.map(({ conversation, read, partial }) => [
                     conversation,
-                    read: read.at,
-                    ...(read.partial ? { partial: true } : {}),
+                    { conversation, read, partial: partial === true },
+                ]));
+                const keys = transaction.objectStore(MESSAGES).index('conversation');
+                await new Promise((resolve, reject) => {
+                    const cursor = keys.openKeyCursor(null, 'nextunique');
+                    cursor.onerror = () => reject(cursor.error);
+                    cursor.onsuccess = () => {
+                        const at = cursor.result;
+                        if (at === null) {
+                            resolve();
+                            return;
+                        }
+                        const conversation = at.key;
+                        if (!held.has(conversation)) {
+                            held.set(conversation, { conversation, read: undefined, partial: true });
+                        }
+                        at.continue();
+                    };
                 });
-            }
-            await completed(transaction);
-        },
-        async messageWindow(conversation, limit) {
-            const transaction = database.transaction(MESSAGES, 'readonly');
-            const index = transaction.objectStore(MESSAGES).index('position');
-            const range = IDBKeyRange.bound([conversation], [conversation, []]);
-            if (limit === undefined) {
-                return (await settled(index.getAll(range))).map(accepted);
-            }
-            const latest = [];
-            if (limit === 0)
-                return latest;
-            await new Promise((resolve, reject) => {
-                const cursor = index.openCursor(range, 'prev');
-                cursor.onerror = () => reject(cursor.error);
-                cursor.onsuccess = () => {
-                    const at = cursor.result;
-                    if (at === null) {
-                        resolve();
-                        return;
-                    }
-                    latest.push(accepted(at.value));
-                    if (latest.length === limit)
-                        resolve();
-                    else
+                return [...held.values()];
+            });
+        },
+        async keepMessages({ conversation, messages, read }) {
+            await transacted(database, [CONVERSATIONS, MESSAGES], 'readwrite', (transaction) => {
+                const stored = transaction.objectStore(MESSAGES);
+                for (const message of messages) {
+                    stored.put({ ...message, conversation });
+                }
+                if (read !== undefined) {
+                    transaction.objectStore(CONVERSATIONS).put({
+                        conversation,
+                        read: read.at,
+                        ...(read.partial ? { partial: true } : {}),
+                    });
+                }
+            });
+        },
+        messageWindow(conversation, limit, before) {
+            return transacted(database, MESSAGES, 'readonly', async (transaction) => {
+                const index = transaction.objectStore(MESSAGES).index('position');
+                const range = IDBKeyRange.bound([conversation], [conversation, before?.[0] ?? []]);
+                const latest = [];
+                let more = false;
+                await new Promise((resolve, reject) => {
+                    const cursor = index.openCursor(range, 'prev');
+                    cursor.onerror = () => reject(cursor.error);
+                    cursor.onsuccess = () => {
+                        const at = cursor.result;
+                        if (at === null) {
+                            resolve();
+                            return;
+                        }
+                        const record = at.value;
+                        if (!precedes(record, before)) {
+                            at.continue();
+                            return;
+                        }
+                        if (latest.length === limit) {
+                            more = true;
+                            resolve();
+                            return;
+                        }
+                        latest.push(accepted(record));
                         at.continue();
-                };
+                    };
+                });
+                return { messages: latest.reverse(), more };
             });
-            return latest.reverse();
+        },
+        messageCount(conversation) {
+            return transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).index('conversation').count(conversation)));
         },
         async messagesAfter(conversation, identity) {
-            const transaction = database.transaction(MESSAGES, 'readonly');
             const range = identity === null
                 ? IDBKeyRange.bound([conversation], [conversation, []])
                 : IDBKeyRange.bound([conversation, identity], [conversation, []], true);
-            const held = await settled(transaction.objectStore(MESSAGES).getAll(range, READ_BATCH));
+            const held = await transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).getAll(range, READ_BATCH)));
             return held.map(accepted);
         },
         async messageIdentities(conversation) {
-            const transaction = database.transaction(MESSAGES, 'readonly');
-            const keys = await settled(transaction.objectStore(MESSAGES).index('conversation').getAllKeys(conversation));
+            const keys = await transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).index('conversation').getAllKeys(conversation)));
             return keys.map((key) => key[1]);
         },
         async turnArrived(conversation, turn) {
-            const transaction = database.transaction(MESSAGES, 'readonly');
-            const held = await settled(transaction.objectStore(MESSAGES).index('turn').count([conversation, turn]));
+            const held = await transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).index('turn').count([conversation, turn])));
             return held > 0;
         },
         async dropConversations(conversations) {
-            const drafts = authored.transaction(CHAT_DRAFTS, 'readwrite');
-            for (const conversation of conversations)
-                drafts.objectStore(CHAT_DRAFTS).delete(conversation);
-            await completed(drafts);
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES], 'readwrite');
-            const messages = transaction.objectStore(MESSAGES);
-            for (const conversation of conversations) {
-                transaction.objectStore(CONVERSATIONS).delete(conversation);
-                const keys = messages.index('conversation').getAllKeys(conversation);
-                keys.onsuccess = () => {
-                    for (const key of keys.result)
-                        messages.delete(key);
-                };
-            }
-            await completed(transaction);
+            await transacted(authored, CHAT_DRAFTS, 'readwrite', (drafts) => {
+                for (const conversation of conversations)
+                    drafts.objectStore(CHAT_DRAFTS).delete(conversation);
+            });
+            await transacted(database, [CONVERSATIONS, MESSAGES], 'readwrite', (transaction) => {
+                const messages = transaction.objectStore(MESSAGES);
+                for (const conversation of conversations) {
+                    transaction.objectStore(CONVERSATIONS).delete(conversation);
+                    const keys = messages.index('conversation').getAllKeys(conversation);
+                    keys.onsuccess = () => {
+                        for (const key of keys.result)
+                            messages.delete(key);
+                    };
+                }
+            });
         },
         async chatDrafts() {
-            const transaction = authored.transaction(CHAT_DRAFTS, 'readonly');
-            const held = await settled(transaction.objectStore(CHAT_DRAFTS).getAll());
+            const held = await transacted(authored, CHAT_DRAFTS, 'readonly', (transaction) => settled(transaction.objectStore(CHAT_DRAFTS).getAll()));
             return held.map(chatDraftRecord);
         },
         async keepChatDrafts(records) {
-            const transaction = authored.transaction(CHAT_DRAFTS, 'readwrite');
-            for (const record of records)
-                transaction.objectStore(CHAT_DRAFTS).put(record);
-            await completed(transaction);
+            await transacted(authored, CHAT_DRAFTS, 'readwrite', (transaction) => {
+                for (const record of records)
+                    transaction.objectStore(CHAT_DRAFTS).put(record);
+            });
         },
         async dropChatDraft(conversation) {
-            const transaction = authored.transaction(CHAT_DRAFTS, 'readwrite');
-            transaction.objectStore(CHAT_DRAFTS).delete(conversation);
-            await completed(transaction);
+            await transacted(authored, CHAT_DRAFTS, 'readwrite', (transaction) => {
+                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
+            });
+        },
+        calls() {
+            return transacted(authored, CALLS, 'readonly', (transaction) => settled(transaction.objectStore(CALLS).getAll()));
+        },
+        async keepCall(record) {
+            await transacted(authored, CALLS, 'readwrite', (transaction) => {
+                transaction.objectStore(CALLS).put(record);
+            });
+        },
+        async dropCall(operation) {
+            await transacted(authored, CALLS, 'readwrite', (transaction) => {
+                transaction.objectStore(CALLS).delete(operation);
+            });
         },
         async keepRoomDraft(record) {
             if (fenced(record.locator))
                 return;
-            const transaction = authored.transaction(ROOM_DRAFTS, 'readwrite');
-            transaction.objectStore(ROOM_DRAFTS).put(record);
-            await completed(transaction);
+            await transacted(authored, ROOM_DRAFTS, 'readwrite', (transaction) => {
+                transaction.objectStore(ROOM_DRAFTS).put(record);
+            });
         },
         async discardRoomDraft(locator, path) {
             if (fenced(locator))
                 return;
-            const transaction = authored.transaction(ROOM_DRAFTS, 'readwrite');
-            transaction.objectStore(ROOM_DRAFTS).delete([locator, path]);
-            await completed(transaction);
+            await transacted(authored, ROOM_DRAFTS, 'readwrite', (transaction) => {
+                transaction.objectStore(ROOM_DRAFTS).delete([locator, path]);
+            });
         },
         async fences() {
-            const transaction = authored.transaction(FENCES, 'readonly');
-            const held = await settled(transaction.objectStore(FENCES).getAll());
+            const held = await transacted(authored, FENCES, 'readonly', (transaction) => settled(transaction.objectStore(FENCES).getAll()));
             return held.map((fence) => fence.locator);
         },
         async erase(locators) {
-            const work = authored.transaction([FENCES, QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
-            for (const locator of locators) {
-                work.objectStore(FENCES).put({ locator });
-                work.objectStore(QUEUES).delete(locator);
-                for (const name of [PENDING_CHANGES, ROOM_DRAFTS]) {
-                    removeRoomEntries(work.objectStore(name), locator);
+            await transacted(authored, [FENCES, QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite', (work) => {
+                for (const locator of locators) {
+                    work.objectStore(FENCES).put({ locator });
+                    work.objectStore(QUEUES).delete(locator);
+                    for (const name of [PENDING_CHANGES, ROOM_DRAFTS]) {
+                        removeRoomEntries(work.objectStore(name), locator);
+                    }
                 }
-            }
-            await completed(work);
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_FILES, TRANSFERS], 'readwrite');
-            for (const locator of locators) {
-                transaction.objectStore(ROOMS).delete(locator);
-                transaction.objectStore(TRANSFERS).delete(locator);
-                transaction.objectStore(DOCUMENTS).delete(underRoom(locator));
-                transaction.objectStore(BINARY_FILES).delete(underRoom(locator));
-            }
-            await completed(transaction);
-            const fences = authored.transaction(FENCES, 'readwrite');
-            for (const locator of locators)
-                fences.objectStore(FENCES).delete(locator);
-            await completed(fences);
+            });
+            await transacted(database, [ROOMS, DOCUMENTS, BINARY_FILES, TRANSFERS], 'readwrite', (transaction) => {
+                for (const locator of locators) {
+                    transaction.objectStore(ROOMS).delete(locator);
+                    transaction.objectStore(TRANSFERS).delete(locator);
+                    transaction.objectStore(DOCUMENTS).delete(underRoom(locator));
+                    transaction.objectStore(BINARY_FILES).delete(underRoom(locator));
+                }
+            });
+            await transacted(authored, FENCES, 'readwrite', (fences) => {
+                for (const locator of locators)
+                    fences.objectStore(FENCES).delete(locator);
+            });
         },
         async discard(locator) {
-            const transaction = authored.transaction([QUEUES, PENDING_CHANGES], 'readwrite');
-            transaction.objectStore(QUEUES).delete(locator);
-            removeRoomEntries(transaction.objectStore(PENDING_CHANGES), locator);
-            await completed(transaction);
+            await transacted(authored, [QUEUES, PENDING_CHANGES], 'readwrite', (transaction) => {
+                transaction.objectStore(QUEUES).delete(locator);
+                removeRoomEntries(transaction.objectStore(PENDING_CHANGES), locator);
+            });
         },
         async transfers() {
-            const transaction = database.transaction(TRANSFERS, 'readonly');
-            const held = await settled(transaction.objectStore(TRANSFERS).getAll());
+            const held = await transacted(database, TRANSFERS, 'readonly', (transaction) => settled(transaction.objectStore(TRANSFERS).getAll()));
             return held.filter((record) => !fenced(record.locator));
         },
         staged(record) {
-            const transaction = database.transaction([DOCUMENTS, BINARY_FILES], 'readonly');
-            return readLayer(transaction, record.locator, record.transfer);
+            return transacted(database, [DOCUMENTS, BINARY_FILES], 'readonly', (transaction) => readLayer(transaction, record.locator, record.transfer));
         },
         async stage(record, page) {
             if (fenced(record.locator))
                 return;
-            const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite');
-            writeLayer(transaction, record.locator, record.transfer, page, null);
-            transaction.objectStore(TRANSFERS).put(record);
-            await completed(transaction);
+            const paths = await stepped(changedIn(page, null));
+            if (fenced(record.locator))
+                return;
+            await transacted(database, [TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite', (transaction) => {
+                transaction.objectStore(TRANSFERS).put(record);
+                return writeLayer(transaction, record.locator, record.transfer, {
+                    next: page,
+                    base: null,
+                    paths,
+                });
+            });
         },
         async abandon(locator) {
             if (fenced(locator))
                 return;
-            const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite');
-            const transfers = transaction.objectStore(TRANSFERS);
-            const held = transfers.get(locator);
-            held.onsuccess = () => {
-                const record = held.result;
-                if (record === undefined)
-                    return;
-                transfers.delete(locator);
-                const range = underTransfer(locator, record.transfer);
-                transaction.objectStore(DOCUMENTS).delete(range);
-                transaction.objectStore(BINARY_FILES).delete(range);
-            };
-            await completed(transaction);
+            await transacted(database, [TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite', (transaction) => {
+                const transfers = transaction.objectStore(TRANSFERS);
+                const held = transfers.get(locator);
+                held.onsuccess = () => {
+                    const record = held.result;
+                    if (record === undefined)
+                        return;
+                    transfers.delete(locator);
+                    const range = underTransfer(locator, record.transfer);
+                    transaction.objectStore(DOCUMENTS).delete(range);
+                    transaction.objectStore(BINARY_FILES).delete(range);
+                };
+            });
         },
-        async receivedHeads() {
-            const transaction = database.transaction(RECEIVED, 'readonly');
-            return settled(transaction.objectStore(RECEIVED).getAll());
+        receivedHeads() {
+            return transacted(database, RECEIVED, 'readonly', (transaction) => settled(transaction.objectStore(RECEIVED).getAll()));
         },
         async receivedParts(key, count) {
-            const transaction = database.transaction(RECEIVED_PARTS, 'readonly');
-            const kept = await settled(transaction
+            const kept = await transacted(database, RECEIVED_PARTS, 'readonly', (transaction) => settled(transaction
                 .objectStore(RECEIVED_PARTS)
-                .getAll(IDBKeyRange.bound([key, 0], [key, count], false, true)));
+                .getAll(IDBKeyRange.bound([key, 0], [key, count], false, true))));
             return kept.map((part) => part.value);
         },
         async keepReceived(key, head, part) {
-            const transaction = database.transaction([RECEIVED, RECEIVED_PARTS], 'readwrite');
-            transaction.objectStore(RECEIVED).put({ key, head });
-            if (part !== undefined)
-                transaction.objectStore(RECEIVED_PARTS).put({ key, ...part });
-            await completed(transaction);
+            await transacted(database, [RECEIVED, RECEIVED_PARTS], 'readwrite', (transaction) => {
+                transaction.objectStore(RECEIVED).put({ key, head });
+                if (part !== undefined)
+                    transaction.objectStore(RECEIVED_PARTS).put({ key, ...part });
+            });
         },
         async dropReceived(keys) {
-            const transaction = database.transaction([RECEIVED, RECEIVED_PARTS], 'readwrite');
-            for (const key of keys) {
-                transaction.objectStore(RECEIVED).delete(key);
-                transaction.objectStore(RECEIVED_PARTS).delete(IDBKeyRange.bound([key], [key, []]));
-            }
-            await completed(transaction);
+            await transacted(database, [RECEIVED, RECEIVED_PARTS], 'readwrite', (transaction) => {
+                for (const key of keys) {
+                    transaction.objectStore(RECEIVED).delete(key);
+                    transaction.objectStore(RECEIVED_PARTS).delete(IDBKeyRange.bound([key], [key, []]));
+                }
+            });
         },
         async generation() {
-            const transaction = authored.transaction(FACTS, 'readonly');
-            const held = await settled(transaction.objectStore(FACTS).get(GENERATION));
+            const held = await transacted(authored, FACTS, 'readonly', (transaction) => settled(transaction.objectStore(FACTS).get(GENERATION)));
             return held ?? null;
         },
         async rememberGeneration(value) {
-            const transaction = authored.transaction(FACTS, 'readwrite');
-            transaction.objectStore(FACTS).put(value, GENERATION);
-            await completed(transaction);
+            await transacted(authored, FACTS, 'readwrite', (transaction) => {
+                transaction.objectStore(FACTS).put(value, GENERATION);
+            });
         },
         close() {
-            authored.close();
-            database.close();
+            for (const held of [authored, database])
+                void idle(held).then(() => held.close());
         },
     };
 }