@agentshouse/mdruntime 0.1.0-cbb8d8acc9d19 → 0.1.0-cc56db96f86ae

package/dist/store.js

@@ -1,247 +1,443 @@
-import { sameChange } from './overlay.js';
+import { sameBinary, sameChange } from './overlay.js';
+import { differences, keysIn } from './shared.js';
+import { inUnits, ROW_WEIGHT, stepped } from './turn.js';
+import { precedes } from './windows.js';
+import { binaryLocalId } from './identity.js';
 const DATABASE = 'mdruntime';
 const ROOMS = 'rooms';
 const DOCUMENTS = 'documents';
-const BINARY_TARGETS = 'binaryTargets';
-const ATTACHMENTS = 'attachments';
-const PENDING_CHANGES = 'pendingChanges';
+const BINARY_FILES = 'binaryFiles';
+const TRANSFERS = 'transfers';
+const RECEIVED = 'received';
+const RECEIVED_PARTS = 'receivedParts';
 const DECLARATIONS = 'declarations';
-const ROOM_DRAFTS = 'roomDrafts';
 const PRESENTATION = 'presentation';
 const CONVERSATIONS = 'conversations';
 const MESSAGES = 'messages';
-const CHAT_DRAFTS = 'chatDrafts';
 const CURRENT = 'current';
-export const STORE_SCHEMA = 20;
+const MEMBER = 'member';
+const TARGETS = 'targets';
+const FILE = '\u0000file';
+export const STORE_SCHEMA = 25;
+const REPLICA_SHAPE = 23;
+const REPLICA_STORES = [
+    [ROOMS, { keyPath: 'locator' }],
+    [DOCUMENTS, { keyPath: ['locator', 'transfer', 'path'] }],
+    [BINARY_FILES, { keyPath: ['locator', 'transfer', 'path'] }],
+    [TRANSFERS, { keyPath: 'locator' }],
+    [RECEIVED, { keyPath: 'key' }],
+    [RECEIVED_PARTS, { keyPath: ['key', 'index'] }],
+    [DECLARATIONS, undefined],
+    [PRESENTATION, { keyPath: 'app' }],
+    [CONVERSATIONS, { keyPath: 'conversation' }],
+    [MESSAGES, { keyPath: ['conversation', 'identity'] }],
+];
+const READ_BATCH = 256;
+const MESSAGE_INDEXES = [
+    ['conversation', 'conversation'],
+    ['position', ['conversation', 'position']],
+    ['turn', ['conversation', 'turn']],
+];
 function settled(request) {
     return new Promise((resolve, reject) => {
         request.onsuccess = () => resolve(request.result);
         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 = {
     lastCompleted: null,
-    generation: null,
     providerLimits: [],
     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 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 accepted({ conversation: _held, ...message }) {
+    return message;
+}
+function roomRecord(record) {
+    const { documents, binaries, revisions, fileIds, changes, written, ...room } = record;
+    return room;
+}
+function underTransfer(locator, transfer, after) {
+    return after === undefined
+        ? IDBKeyRange.bound([locator, transfer], [locator, transfer, []])
+        : IDBKeyRange.bound([locator, transfer, after], [locator, transfer, []], true);
+}
+function underRoom(locator) {
+    return IDBKeyRange.bound([locator], [locator, []]);
+}
+async function readTransfer(store, locator, transfer, receive) {
+    let range = underTransfer(locator, transfer);
+    for (;;) {
+        const batch = await settled(store.getAll(range, READ_BATCH));
+        for (const record of batch)
+            receive(record);
+        if (batch.length < READ_BATCH)
+            return;
+        range = underTransfer(locator, transfer, batch[batch.length - 1].path);
+    }
+}
+function emptyLayer() {
+    return { documents: {}, binaries: {}, revisions: {}, fileIds: {}, changes: {}, written: {} };
+}
+async function readLayer(transaction, locator, transfer) {
+    const layer = emptyLayer();
+    const head = (held) => {
+        if (held.revision !== null)
+            layer.revisions[held.path] = held.revision;
+        if (held.fileId !== null)
+            layer.fileIds[held.path] = held.fileId;
+        if (held.change !== null)
+            layer.changes[held.path] = held.change;
     };
-    return completed(transaction);
+    await readTransfer(transaction.objectStore(DOCUMENTS), locator, transfer, (document) => {
+        layer.documents[document.path] = document.content;
+        if (document.written !== null)
+            layer.written[document.path] = document.written;
+        head(document);
+    });
+    await readTransfer(transaction.objectStore(BINARY_FILES), locator, transfer, (file) => {
+        layer.binaries[file.path] = file.binary;
+        head(file);
+    });
+    return layer;
 }
-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 });
+function documentRecord(locator, transfer, layer, path) {
+    return {
+        locator,
+        transfer,
+        path,
+        content: layer.documents[path],
+        revision: layer.revisions[path] ?? null,
+        fileId: layer.fileIds[path] ?? null,
+        change: layer.changes[path] ?? null,
+        written: layer.written[path] ?? null,
     };
-    return completed(transaction);
 }
-function roomRecord(record, queue) {
-    const { documents, binaryTargets, revisions, changes, written, attachments, ...room } = record;
-    return { ...room, order: queue.map((batch) => batch.id) };
+function binaryFileRecord(locator, transfer, layer, path) {
+    return {
+        locator,
+        transfer,
+        path,
+        revision: layer.revisions[path] ?? null,
+        fileId: layer.fileIds[path] ?? null,
+        change: layer.changes[path] ?? null,
+        binary: layer.binaries[path],
+    };
 }
-function removeRoomEntries(store, locator) {
-    const keys = store.getAllKeys();
-    keys.onsuccess = () => {
-        for (const key of keys.result) {
-            if (Array.isArray(key) && key[0] === locator)
-                store.delete(key);
+function* changedIn(next, base) {
+    if (base === null)
+        return yield* keysIn(next.documents, 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);
+    let last = null;
+    return inUnits(paths, (path) => {
+        if (next.documents[path] !== undefined) {
+            last = documents.put(documentRecord(locator, transfer, next, path));
         }
-    };
+        else if (base?.documents[path] !== undefined) {
+            last = documents.delete([locator, transfer, path]);
+        }
+        if (next.binaries[path] !== undefined) {
+            last = files.put(binaryFileRecord(locator, transfer, next, path));
+        }
+        else if (base?.binaries[path] !== undefined) {
+            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()));
+    });
 }
-export function removeRuntimeStore() {
+function removeDatabase(name) {
     return new Promise((resolve, reject) => {
-        const removal = indexedDB.deleteDatabase(DATABASE);
+        const removal = indexedDB.deleteDatabase(name);
         removal.onsuccess = () => resolve();
         removal.onerror = () => reject(removal.error);
     });
 }
-export async function openRuntimeStore() {
-    const opening = indexedDB.open(DATABASE, STORE_SCHEMA);
-    opening.onupgradeneeded = () => {
+export async function endRuntimeStore(database, holder) {
+    await removeDatabase(DATABASE);
+    return database.ask({ kind: 'authored.end', holder: holder ?? null });
+}
+export function openDatabase(name, version, upgrade) {
+    return new Promise((resolve, reject) => {
+        const opening = indexedDB.open(name, version);
+        opening.onupgradeneeded = (event) => upgrade(opening, event.oldVersion);
+        opening.onsuccess = () => resolve(opening.result);
+        opening.onerror = () => {
+            if (opening.error?.name !== 'VersionError') {
+                reject(opening.error);
+                return;
+            }
+            removeDatabase(name)
+                .then(() => openDatabase(name, version, upgrade))
+                .then(resolve, reject);
+        };
+    });
+}
+function openReplica() {
+    return openDatabase(DATABASE, STORE_SCHEMA, (opening, oldVersion) => {
         const database = opening.result;
-        for (const name of [...database.objectStoreNames])
-            database.deleteObjectStore(name);
-        database.createObjectStore(ROOMS, { keyPath: 'locator' });
-        database.createObjectStore(DOCUMENTS, { keyPath: ['locator', 'path'] });
-        database.createObjectStore(BINARY_TARGETS, { keyPath: ['locator', 'path'] });
-        database.createObjectStore(ATTACHMENTS, { keyPath: ['locator', 'reference'] });
-        database.createObjectStore(PENDING_CHANGES, { keyPath: ['locator', 'id'] });
-        database.createObjectStore(DECLARATIONS);
-        database.createObjectStore(ROOM_DRAFTS, { keyPath: ['locator', 'path'] });
-        database.createObjectStore(PRESENTATION, { keyPath: 'app' });
-        database.createObjectStore(CONVERSATIONS, { keyPath: 'conversation' });
-        const messages = database.createObjectStore(MESSAGES, {
-            keyPath: ['conversation', 'identity'],
+        if (oldVersion < REPLICA_SHAPE) {
+            for (const name of [...database.objectStoreNames])
+                database.deleteObjectStore(name);
+        }
+        for (const [name, parameters] of REPLICA_STORES) {
+            if (database.objectStoreNames.contains(name))
+                continue;
+            database.createObjectStore(name, parameters);
+        }
+        const messages = opening.transaction.objectStore(MESSAGES);
+        for (const [name, keyPath] of MESSAGE_INDEXES) {
+            if (!messages.indexNames.contains(name))
+                messages.createIndex(name, keyPath);
+        }
+    });
+}
+function batchFiles(batch) {
+    return batch.changes.flatMap((change) => (change.kind === 'binary' ? [change.localId] : []));
+}
+function draftFiles(drafts) {
+    return drafts.flatMap(({ parts }) => (parts.file === undefined ? [] : [parts.file.localId]));
+}
+function roomDraftRow(record) {
+    return { path: record.path, record: JSON.stringify(record), files: draftFiles([record]) };
+}
+function authoredRows({ locator, queue, founded, saved, roomDrafts, consumedRoomDrafts }, held) {
+    return {
+        locator,
+        ...(queue === undefined
+            ? {}
+            : {
+                order: queue.map(({ id }) => id),
+                added: queue
+                    .filter(({ id }) => held?.has(id) !== true)
+                    .map((batch) => {
+                    const drafts = saved?.get(batch.id) ?? [];
+                    return {
+                        id: batch.id,
+                        batch: JSON.stringify(batch),
+                        state: JSON.stringify({
+                            drafts,
+                            submission: { state: 'waiting' },
+                            lost: false,
+                        }),
+                        files: [...batchFiles(batch), ...draftFiles(drafts)],
+                    };
+                }),
+            }),
+        ...(founded === undefined
+            ? {}
+            : {
+                founded: founded.map((batch) => ({
+                    id: batch.id,
+                    batch: JSON.stringify(batch),
+                    files: batchFiles(batch),
+                })),
+            }),
+        ...(roomDrafts === undefined ? {} : { roomDrafts: roomDrafts.map(roomDraftRow) }),
+        ...(consumedRoomDrafts === undefined ? {} : { consumedRoomDrafts }),
+    };
+}
+function marked(value) {
+    return typeof value === 'object' && value !== null && FILE in value;
+}
+function keyed(keys, value) {
+    const stored = [];
+    const files = [];
+    const record = JSON.stringify(value, (_name, held) => {
+        if (!(held instanceof Blob))
+            return held;
+        let key = keys.get(held);
+        if (key === undefined) {
+            key = binaryLocalId();
+            keys.set(held, key);
+        }
+        stored.push({ key, blob: held });
+        files.push(key);
+        return { [FILE]: key, type: held.type };
+    });
+    return { record, files, stored };
+}
+async function filed(value, read) {
+    if (Array.isArray(value))
+        return Promise.all(value.map((item) => filed(item, read)));
+    if (marked(value))
+        return read(value[FILE], value.type);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const restored = {};
+    for (const [name, item] of Object.entries(value))
+        restored[name] = await filed(item, read);
+    return restored;
+}
+export async function openRuntimeStore(fenced, authored) {
+    const database = await openReplica();
+    const keys = new WeakMap();
+    const read = async (key, type) => {
+        const blob = await authored.ask({ kind: 'authored.file', key, type });
+        keys.set(blob, key);
+        return blob;
+    };
+    const restored = async (records) => Promise.all(records.map(async (record) => (await filed(JSON.parse(record), read))));
+    const amend = async (locator, id, amendment) => {
+        if (fenced(locator))
+            return;
+        await authored.ask({
+            kind: 'authored.amend',
+            locator,
+            id,
+            amendment: JSON.stringify(amendment),
         });
-        messages.createIndex('conversation', 'conversation');
-        database.createObjectStore(CHAT_DRAFTS, { keyPath: 'conversation' });
     };
-    const database = await settled(opening);
+    const fact = (name) => authored.ask({ kind: 'authored.fact', name });
+    const queued = new Map();
+    const rows = (writes) => writes.map((write) => authoredRows(write, queued.get(write.locator)));
+    const noted = (writes) => {
+        for (const { locator, queue } of writes) {
+            if (queue !== undefined)
+                queued.set(locator, new Set(queue.map(({ id }) => id)));
+        }
+    };
     return {
-        async all() {
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS], 'readonly');
-            const [rooms, documents, targets, attachments] = await Promise.all([
-                settled(transaction.objectStore(ROOMS).getAll()),
-                settled(transaction.objectStore(DOCUMENTS).getAll()),
-                settled(transaction.objectStore(BINARY_TARGETS).getAll()),
-                settled(transaction.objectStore(ATTACHMENTS).getAll()),
-            ]);
-            const byRoom = new Map();
-            for (const { order, ...room } of rooms) {
-                byRoom.set(room.locator, {
-                    ...room,
-                    documents: {},
-                    revisions: {},
-                    changes: {},
-                    written: {},
-                    binaryTargets: [],
-                    attachments: [],
-                });
-            }
-            const head = (room, held) => {
-                if (held.revision !== null) {
-                    room.revisions[held.path] = held.revision;
-                }
-                if (held.change !== null) {
-                    room.changes[held.path] = held.change;
-                }
-            };
-            for (const document of documents) {
-                const room = byRoom.get(document.locator);
-                if (room === undefined)
-                    continue;
-                room.documents[document.path] = document.content;
-                if (document.written !== null) {
-                    room.written[document.path] = document.written;
-                }
-                head(room, document);
-            }
-            for (const target of targets) {
-                const room = byRoom.get(target.locator);
-                if (room === undefined)
-                    continue;
-                room.binaryTargets.push(target.path);
-                head(room, target);
-            }
-            for (const { locator, ...attachment } of attachments) {
-                const room = byRoom.get(locator);
-                if (room === undefined)
-                    continue;
-                room.attachments.push(attachment);
-            }
-            return [...byRoom.values()];
-        },
-        async write({ next, previous, queue, previousQueue, saved, roomDrafts, consumedRoomDrafts }) {
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
-            transaction.objectStore(ROOMS).put(roomRecord(next, queue));
-            const documents = transaction.objectStore(DOCUMENTS);
-            for (const path of Object.keys(previous?.documents ?? {})) {
-                if (next.documents[path] === undefined)
-                    documents.delete([next.locator, path]);
-            }
-            for (const [path, content] of Object.entries(next.documents)) {
-                if (previous?.documents[path] === content &&
-                    previous.revisions[path] === next.revisions[path] &&
-                    previous.written[path] === next.written[path] &&
-                    sameChange(previous.changes[path], next.changes[path]))
-                    continue;
-                documents.put({
-                    locator: next.locator,
-                    path,
-                    content,
-                    revision: next.revisions[path] ?? null,
-                    change: next.changes[path] ?? null,
-                    written: next.written[path] ?? null,
-                });
-            }
-            const targets = transaction.objectStore(BINARY_TARGETS);
-            const beforeTargets = new Set(previous?.binaryTargets ?? []);
-            const afterTargets = new Set(next.binaryTargets);
-            for (const path of beforeTargets) {
-                if (!afterTargets.has(path))
-                    targets.delete([next.locator, path]);
-            }
-            for (const path of afterTargets) {
-                if (!beforeTargets.has(path) ||
-                    previous?.revisions[path] !== next.revisions[path] ||
-                    !sameChange(previous?.changes[path], next.changes[path])) {
-                    targets.put({
-                        locator: next.locator,
-                        path,
-                        revision: next.revisions[path] ?? null,
-                        change: next.changes[path] ?? null,
+        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)),
                     });
                 }
-            }
-            const attachments = transaction.objectStore(ATTACHMENTS);
-            const held = new Map((previous?.attachments ?? []).map((attachment) => [attachment.reference, attachment]));
-            const declared = new Set(next.attachments.map((attachment) => attachment.reference));
-            for (const reference of held.keys()) {
-                if (!declared.has(reference))
-                    attachments.delete([next.locator, reference]);
-            }
-            for (const attachment of next.attachments) {
-                if (held.get(attachment.reference) === attachment)
-                    continue;
-                attachments.put({ ...attachment, locator: next.locator });
-            }
-            if (previousQueue !== undefined) {
-                const pending = transaction.objectStore(PENDING_CHANGES);
-                const before = new Set(previousQueue.map((batch) => batch.id));
-                const after = new Set(queue.map((batch) => batch.id));
-                for (const id of before) {
-                    if (!after.has(id))
-                        pending.delete([next.locator, id]);
-                }
-                for (const batch of queue) {
-                    if (!before.has(batch.id)) {
-                        pending.put({
-                            locator: next.locator,
-                            id: batch.id,
-                            batch,
-                            drafts: saved ?? [],
-                            submission: { state: 'waiting' },
-                            lost: false,
-                        });
-                    }
+                return records;
+            });
+        },
+        async keepAuthored(...writes) {
+            const kept = writes.filter(({ locator }) => !fenced(locator));
+            if (kept.length === 0)
+                return;
+            await authored.ask({ kind: 'authored.keep', writes: rows(kept), files: [], whole: false });
+            noted(kept);
+        },
+        async saveAuthored(files, ...writes) {
+            const refused = writes.find(({ locator }) => fenced(locator));
+            if (refused !== undefined)
+                return refused.locator;
+            const fencedThere = await authored.ask({
+                kind: 'authored.keep',
+                writes: rows(writes),
+                files,
+                whole: true,
+            });
+            if (fencedThere === null)
+                noted(writes);
+            return fencedThere;
+        },
+        async write({ next, previous, stored }) {
+            if (next === previous || fenced(next.locator))
+                return;
+            const moved = previous?.transfer !== next.transfer;
+            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);
                 }
-            }
-            const draftStore = transaction.objectStore(ROOM_DRAFTS);
-            for (const path of consumedRoomDrafts ?? [])
-                draftStore.delete([next.locator, path]);
-            for (const record of roomDrafts ?? [])
-                draftStore.put(record);
-            await completed(transaction);
+                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, queue } of records) {
-                rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }, queue));
-            }
-            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;
@@ -262,134 +458,318 @@ export async function openRuntimeStore() {
                 capabilities,
             }));
         },
+        async member() {
+            const held = await transacted(database, DECLARATIONS, 'readonly', (transaction) => settled(transaction.objectStore(DECLARATIONS).get(MEMBER)));
+            return held ?? null;
+        },
+        async keepMember(member) {
+            await transacted(database, DECLARATIONS, 'readwrite', (transaction) => {
+                transaction.objectStore(DECLARATIONS).put(member, MEMBER);
+            });
+        },
+        async targets() {
+            const held = await transacted(database, DECLARATIONS, 'readonly', (transaction) => settled(transaction.objectStore(DECLARATIONS).get(TARGETS)));
+            return held ?? {};
+        },
+        async keepTargets(targets) {
+            await transacted(database, DECLARATIONS, 'readwrite', (transaction) => {
+                transaction.objectStore(DECLARATIONS).put(targets, TARGETS);
+            });
+        },
         async queues() {
-            const transaction = database.transaction([ROOMS, PENDING_CHANGES], 'readonly');
-            const [rooms, pending] = await Promise.all([
-                settled(transaction.objectStore(ROOMS).getAll()),
-                settled(transaction.objectStore(PENDING_CHANGES).getAll()),
-            ]);
+            const { queues, pending } = await authored.ask({ kind: 'authored.queues' });
+            queued.clear();
+            for (const queue of queues)
+                queued.set(queue.locator, new Set(queue.ids));
             const byId = new Map(pending.map((record) => [`${record.locator}\0${record.id}`, record]));
-            return rooms.map((room) => ({
-                locator: room.locator,
-                pending: room.order.map((id) => {
-                    const record = byId.get(`${room.locator}\0${id}`);
+            return queues
+                .filter((queue) => !fenced(queue.locator))
+                .map((queue) => ({
+                locator: queue.locator,
+                pending: queue.ids.map((id) => {
+                    const record = byId.get(`${queue.locator}\0${id}`);
                     if (record === undefined)
-                        throw new Error(`Missing Pending Change ${room.locator}/${id}`);
-                    const { batch, drafts, submission, lost, upload, accepted } = record;
-                    return { batch, state: { drafts, submission, lost, upload, accepted } };
+                        throw new Error(`Missing Pending Change ${queue.locator}/${id}`);
+                    return {
+                        batch: JSON.parse(record.batch),
+                        state: JSON.parse(record.state),
+                    };
                 }),
             }));
         },
         submit(locator, id, submission, lost) {
-            return amendPending(database, locator, id, { submission, lost });
+            return amend(locator, id, { submission, lost });
         },
         accept(locator, id, roomVersion) {
-            return amendPending(database, locator, id, { accepted: roomVersion });
+            return amend(locator, id, { accepted: roomVersion });
         },
         keepUpload(locator, id, upload) {
-            return amendPending(database, locator, id, { upload });
+            return amend(locator, id, { upload });
         },
         async roomDrafts() {
-            const transaction = database.transaction(ROOM_DRAFTS, 'readonly');
-            return settled(transaction.objectStore(ROOM_DRAFTS).getAll());
+            const held = await authored.ask({ kind: 'authored.roomDrafts' });
+            return held
+                .map((record) => JSON.parse(record))
+                .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 [reads, messages] = await Promise.all([
-                settled(transaction.objectStore(CONVERSATIONS).getAll()),
-                settled(transaction.objectStore(MESSAGES).getAll()),
-            ]);
-            const held = new Map();
-            for (const { conversation, read } of reads) {
-                held.set(conversation, { conversation, read, messages: [] });
-            }
-            for (const { conversation, ...message } of messages) {
-                const entry = held.get(conversation) ?? { conversation, read: undefined, messages: [] };
-                entry.messages.push(message);
-                held.set(conversation, entry);
-            }
-            return [...held.values()];
+            await transacted(database, PRESENTATION, 'readwrite', (transaction) => {
+                transaction.objectStore(PRESENTATION).put(record);
+            });
         },
-        async keepMessages({ conversation, messages, read, sealed }) {
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES, CHAT_DRAFTS], 'readwrite');
-            const stored = transaction.objectStore(MESSAGES);
-            for (const message of messages) {
-                stored.put({ ...message, conversation });
-            }
-            if (read !== undefined) {
-                transaction
-                    .objectStore(CONVERSATIONS)
-                    .put({ conversation, read });
-            }
-            if (sealed === true)
-                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
-            await completed(transaction);
+        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,
+                    { 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();
+                    };
+                });
+                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 };
+            });
+        },
+        messageCount(conversation) {
+            return transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).index('conversation').count(conversation)));
+        },
+        async messagesAfter(conversation, identity) {
+            const range = identity === null
+                ? IDBKeyRange.bound([conversation], [conversation, []])
+                : IDBKeyRange.bound([conversation, identity], [conversation, []], true);
+            const held = await transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).getAll(range, READ_BATCH)));
+            return held.map(accepted);
+        },
+        async messageIdentities(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 held = await transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).index('turn').count([conversation, turn])));
+            return held > 0;
         },
         async dropConversations(conversations) {
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES, CHAT_DRAFTS], 'readwrite');
-            const messages = transaction.objectStore(MESSAGES);
-            for (const conversation of conversations) {
-                transaction.objectStore(CONVERSATIONS).delete(conversation);
-                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
-                const keys = messages.index('conversation').getAllKeys(conversation);
-                keys.onsuccess = () => {
-                    for (const key of keys.result)
-                        messages.delete(key);
-                };
-            }
-            await completed(transaction);
+            await authored.ask({ kind: 'authored.chatDraft', kept: [], dropped: conversations });
+            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 = database.transaction(CHAT_DRAFTS, 'readonly');
-            return settled(transaction.objectStore(CHAT_DRAFTS).getAll());
+            const records = await authored.ask({ kind: 'authored.chatDrafts' });
+            return records.map((record) => JSON.parse(record));
         },
-        async keepChatDraft(record) {
-            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
-            transaction.objectStore(CHAT_DRAFTS).put(record);
-            await completed(transaction);
+        async keepChatDrafts(records) {
+            await authored.ask({
+                kind: 'authored.chatDraft',
+                kept: records.map((record) => ({
+                    conversation: record.conversation,
+                    record: JSON.stringify(record),
+                })),
+                dropped: [],
+            });
         },
         async dropChatDraft(conversation) {
-            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
-            transaction.objectStore(CHAT_DRAFTS).delete(conversation);
-            await completed(transaction);
+            await authored.ask({ kind: 'authored.chatDraft', kept: [], dropped: [conversation] });
+        },
+        async calls() {
+            return restored(await authored.ask({ kind: 'authored.calls' }));
         },
-        async keepRoomDraft(record) {
-            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
-            transaction.objectStore(ROOM_DRAFTS).put(record);
-            await completed(transaction);
+        async keepCall(record) {
+            const { stored, ...kept } = keyed(keys, record);
+            await authored.ask({
+                kind: 'authored.call',
+                operation: record.operation,
+                kept,
+                files: stored,
+            });
+        },
+        async dropCall(operation) {
+            await authored.ask({ kind: 'authored.call', operation, kept: null, files: [] });
+        },
+        async keepRoomDraft(record, files) {
+            if (fenced(record.locator))
+                return;
+            const { path, ...kept } = roomDraftRow(record);
+            await authored.ask({
+                kind: 'authored.roomDraft',
+                locator: record.locator,
+                path,
+                kept,
+                files,
+            });
         },
         async discardRoomDraft(locator, path) {
-            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
-            transaction.objectStore(ROOM_DRAFTS).delete([locator, path]);
-            await completed(transaction);
-        },
-        async dropRooms(locators) {
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
-            for (const locator of locators) {
-                transaction.objectStore(ROOMS).delete(locator);
-                for (const name of [DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, PENDING_CHANGES, ROOM_DRAFTS]) {
-                    removeRoomEntries(transaction.objectStore(name), locator);
+            if (fenced(locator))
+                return;
+            await authored.ask({ kind: 'authored.roomDraft', locator, path, kept: null, files: [] });
+        },
+        fences() {
+            return authored.ask({ kind: 'authored.fences' });
+        },
+        async erase(locators) {
+            await authored.ask({ kind: 'authored.fence', locators });
+            for (const locator of locators)
+                queued.delete(locator);
+            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 completed(transaction);
+            });
+            await authored.ask({ kind: 'authored.unfence', locators });
+        },
+        async discard(locator) {
+            await authored.ask({ kind: 'authored.discard', locator });
+            queued.delete(locator);
+        },
+        async transfers() {
+            const held = await transacted(database, TRANSFERS, 'readonly', (transaction) => settled(transaction.objectStore(TRANSFERS).getAll()));
+            return held.filter((record) => !fenced(record.locator));
+        },
+        staged(record) {
+            return transacted(database, [DOCUMENTS, BINARY_FILES], 'readonly', (transaction) => readLayer(transaction, record.locator, record.transfer));
+        },
+        async stage(record, page) {
+            if (fenced(record.locator))
+                return;
+            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;
+            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);
+                };
+            });
+        },
+        receivedHeads() {
+            return transacted(database, RECEIVED, 'readonly', (transaction) => settled(transaction.objectStore(RECEIVED).getAll()));
+        },
+        async receivedParts(key, count) {
+            const kept = await transacted(database, RECEIVED_PARTS, 'readonly', (transaction) => settled(transaction
+                .objectStore(RECEIVED_PARTS)
+                .getAll(IDBKeyRange.bound([key, 0], [key, count], false, true))));
+            return kept.map((part) => part.value);
+        },
+        async keepReceived(key, head, part) {
+            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) {
+            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, []]));
+                }
+            });
+        },
+        generation() {
+            return fact('generation');
         },
-        async generation() {
-            return (await declaration(database)).generation;
+        async rememberGeneration(value) {
+            await authored.ask({ kind: 'authored.remember', name: 'generation', value });
         },
-        rememberGeneration(value) {
-            return updateDeclaration(database, (record) => ({ ...record, generation: value }));
+        file(key, type) {
+            return authored.ask({ kind: 'authored.file', key, type });
         },
         close() {
-            database.close();
+            void idle(database).then(() => database.close());
         },
     };
 }