@agentshouse/mdruntime 0.1.0-cb0eb0d87ff49 → 0.1.0-cb1f56e16291b

package/dist/store.js

@@ -1,705 +1,405 @@
-import { sameBinary, sameChange } from './overlay.js';
-import { differing } from './shared.js';
-const DATABASE = 'mdruntime';
-const AUTHORED = 'mdruntime-authored';
-const FENCES = 'fences';
-const ROOMS = 'rooms';
-const DOCUMENTS = 'documents';
-const BINARY_FILES = 'binaryFiles';
-const TRANSFERS = 'transfers';
-const RECEIVED = 'received';
-const RECEIVED_PARTS = 'receivedParts';
-const PENDING_CHANGES = 'pendingChanges';
-const DECLARATIONS = 'declarations';
-const ROOM_DRAFTS = 'roomDrafts';
-const PRESENTATION = 'presentation';
-const CONVERSATIONS = 'conversations';
-const MESSAGES = 'messages';
-const CHAT_DRAFTS = 'chatDrafts';
-const QUEUES = 'queues';
-const FACTS = 'facts';
-const CURRENT = 'current';
-const MEMBER = 'member';
-const GENERATION = 'generation';
-const HOLDER = 'holder';
-const BINDING = 'binding';
-export const STORE_SCHEMA = 25;
-const REPLICA_SHAPE = 23;
-export const AUTHORED_SCHEMA = 2;
-const AUTHORED_STORES = [
-    [QUEUES, { keyPath: 'locator' }],
-    [PENDING_CHANGES, { keyPath: ['locator', 'id'] }],
-    [ROOM_DRAFTS, { keyPath: ['locator', 'path'] }],
-    [CHAT_DRAFTS, { keyPath: 'conversation' }],
-    [FACTS, undefined],
-    [FENCES, { keyPath: 'locator' }],
-];
-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 EMPTY_DECLARATIONS = {
-    lastCompleted: null,
-    providerLimits: [],
-    capabilities: [],
-};
-function declaration(database) {
-    const transaction = database.transaction(DECLARATIONS, 'readonly');
-    return 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);
-}
-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);
-}
-function accepted({ conversation: _held, ...message }) {
-    return message;
-}
-function roomRecord(record) {
-    const { documents, binaries, revisions, changes, written, ...room } = record;
-    return room;
-}
-function chatDraftRecord(record) {
-    return { ...record, revision: record.revision ?? '' };
+import { composedOf } from './collection.js';
+import { binaryLocalId } from './identity.js';
+const FILE = '\u0000file';
+function batchFiles(batch) {
+    return batch.changes.flatMap((change) => (change.kind === 'binary' ? [change.localId] : []));
 }
-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 draftFiles(drafts) {
+    return drafts.flatMap(({ parts }) => (parts.file === undefined ? [] : [parts.file.localId]));
 }
-function emptyLayer() {
-    return { documents: {}, binaries: {}, revisions: {}, changes: {}, written: {} };
+function roomDraftRow(record) {
+    return { path: record.path, record: JSON.stringify(record), files: draftFiles([record]) };
 }
-async function readLayer(transaction, locator, transfer) {
-    const layer = emptyLayer();
-    const head = (held) => {
-        if (held.revision !== null)
-            layer.revisions[held.path] = held.revision;
-        if (held.change !== null)
-            layer.changes[held.path] = held.change;
-    };
-    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 documentRecord(locator, transfer, layer, path) {
+function authoredRows({ locator, queue, founded, saved, roomDrafts, consumedRoomDrafts }, held) {
     return {
         locator,
-        transfer,
-        path,
-        content: layer.documents[path],
-        revision: layer.revisions[path] ?? null,
-        change: layer.changes[path] ?? null,
-        written: layer.written[path] ?? null,
-    };
-}
-function binaryFileRecord(locator, transfer, layer, path) {
-    return {
-        locator,
-        transfer,
-        path,
-        revision: layer.revisions[path] ?? null,
-        change: layer.changes[path] ?? null,
-        binary: layer.binaries[path],
+        ...(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 writeLayer(transaction, locator, transfer, next, base) {
-    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.written, next.written),
-            ...differing(base.changes, next.changes, sameChange),
-            ...differing(base.binaries, next.binaries, sameBinary),
-        ]);
-    for (const path of paths) {
-        if (next.documents[path] !== undefined) {
-            documents.put(documentRecord(locator, transfer, next, path));
-        }
-        else if (base?.documents[path] !== undefined) {
-            documents.delete([locator, transfer, path]);
-        }
-        if (next.binaries[path] !== undefined) {
-            files.put(binaryFileRecord(locator, transfer, next, path));
-        }
-        else if (base?.binaries[path] !== undefined) {
-            files.delete([locator, transfer, path]);
-        }
-    }
+function marked(value) {
+    return typeof value === 'object' && value !== null && FILE in value;
 }
-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 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);
         }
-    };
-}
-function removeDatabase(name) {
-    return new Promise((resolve, reject) => {
-        const removal = indexedDB.deleteDatabase(name);
-        removal.onsuccess = () => resolve();
-        removal.onerror = () => reject(removal.error);
+        stored.push({ key, blob: held });
+        files.push(key);
+        return { [FILE]: key, type: held.type };
     });
+    return { record, files, stored };
 }
-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;
-    }
-    finally {
-        authored.close();
-    }
-}
-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);
-        return owned;
-    }
-    finally {
-        authored.close();
-    }
-}
-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;
-    }
-    finally {
-        authored.close();
-    }
-}
-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);
-    }
-    finally {
-        authored.close();
-    }
+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 removeRuntimeStore(holder) {
-    await removeDatabase(DATABASE);
-    if (holder !== undefined && (await authoredBy(holder)))
-        return true;
-    await removeDatabase(AUTHORED);
-    return false;
+function json(value, fallback) {
+    return value === undefined ? fallback : JSON.parse(value);
 }
-function openReplica() {
-    const opening = indexedDB.open(DATABASE, STORE_SCHEMA);
-    opening.onupgradeneeded = (event) => {
-        const database = opening.result;
-        if (event.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);
-        }
+export function openRuntimeStore(fenced, authored) {
+    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;
     };
-    return settled(opening);
-}
-function openAuthored() {
-    const opening = indexedDB.open(AUTHORED, AUTHORED_SCHEMA);
-    opening.onupgradeneeded = () => {
-        const database = opening.result;
-        for (const [name, parameters] of AUTHORED_STORES) {
-            if (!database.objectStoreNames.contains(name))
-                database.createObjectStore(name, parameters);
+    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),
+        });
+    };
+    const fact = (name) => authored.ask({ kind: 'authored.fact', name });
+    const queued = new Map();
+    const changed = new Map();
+    const change = (key) => changed.set(key, (changed.get(key) ?? 0) + 1);
+    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 settled(opening);
-}
-export async function openRuntimeStore(fenced) {
-    const authored = await openAuthored();
-    const database = await openReplica().catch((error) => {
-        authored.close();
-        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)) });
+        async opened() {
+            const held = await authored.ask({ kind: 'replica.open' });
+            const unindexed = new Set(held.keys.flatMap(({ key, rederiving }) => (rederiving === null ? [] : [key])));
+            const overlaid = new Map();
+            for (const { key, path } of held.overlaid) {
+                const paths = overlaid.get(key) ?? new Set();
+                paths.add(path);
+                overlaid.set(key, paths);
             }
-            return records;
+            return {
+                rooms: new Map(held.rooms
+                    .filter(({ locator }) => !fenced(locator))
+                    .map(({ locator, key, record }) => [
+                    locator,
+                    { ...JSON.parse(record), key },
+                ])),
+                unindexed,
+                overlaid,
+                erasing: held.erasing.length > 0,
+                orphans: held.orphans,
+                lastCompleted: json(held.facts.lastCompleted, null),
+                providerLimits: json(held.facts.providerLimits, []),
+                capabilities: json(held.facts.capabilities, []),
+                member: json(held.facts.member, null),
+                targets: json(held.facts.targets, {}),
+                presentation: held.presentation.map(({ app, value }) => ({
+                    app,
+                    value: JSON.parse(value),
+                })),
+                conversationList: json(held.facts.conversationList, null),
+                conversationCursor: json(held.facts.conversationCursor, null),
+            };
+        },
+        counts(rooms) {
+            return authored.ask({ kind: 'replica.counts', rooms });
+        },
+        query(plan, rooms, budget) {
+            return authored.ask({ kind: 'replica.query', plan, rooms, budget });
+        },
+        changes(keys) {
+            return keys.reduce((total, key) => total + (changed.get(key) ?? 0), 0);
+        },
+        entries(key, view, paths) {
+            return authored.ask({ kind: 'replica.entries', key, view, paths });
+        },
+        typed(key, view, paths) {
+            return authored.ask({ kind: 'replica.typed', key, view, paths });
+        },
+        referrers(key, view, targets, kinds) {
+            return authored.ask({ kind: 'replica.referrers', key, view, targets, kinds });
+        },
+        files(key, view, after, limit) {
+            return authored.ask({ kind: 'replica.files', key, view, after, limit });
+        },
+        folders(key, view, paths) {
+            return authored.ask({ kind: 'replica.folders', key, view, paths });
+        },
+        typedWithin(key, view, roots, within) {
+            return authored.ask({ kind: 'replica.typedWithin', key, view, roots, within });
+        },
+        async stage(record, composition, page) {
+            if (fenced(record.locator))
+                return null;
+            return authored.ask({
+                kind: 'replica.stage',
+                locator: record.locator,
+                transfer: record.transfer,
+                key: record.key,
+                fingerprint: composedOf(composition).fingerprint,
+                entries: page.entries,
+                folders: page.folders,
+            });
+        },
+        async refresh(key, composition, page) {
+            await authored.ask({
+                kind: 'replica.refresh',
+                key,
+                composed: composedOf(composition),
+                entries: page.entries,
+                removals: page.removals,
+                folders: page.folders,
+                folderRemovals: page.folderRemovals,
+            });
+        },
+        async unrefresh(key) {
+            await authored.ask({ kind: 'replica.unrefresh', key });
         },
-        async keepAuthored({ locator, queue, saved, roomDrafts, consumedRoomDrafts }) {
+        async hold(locator, key, composition, texts) {
             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,
-                        });
-                    }
-                }
-            };
-            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);
-        },
-        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);
-        },
-        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);
+                return [];
+            change(key);
+            return authored.ask({
+                kind: 'replica.hold',
+                key,
+                locator,
+                composed: composedOf(composition),
+                texts,
+            });
         },
-        async lastCompleted() {
-            return (await declaration(database)).lastCompleted;
+        async unhold(locator, key, composition) {
+            if (fenced(locator))
+                return { paths: [], bytes: 0 };
+            change(key);
+            return authored.ask({
+                kind: 'replica.unhold',
+                key,
+                locator,
+                composed: composedOf(composition),
+            });
         },
-        complete(at) {
-            return updateDeclaration(database, (record) => ({ ...record, lastCompleted: at }));
+        async wanted(locator, key) {
+            if (fenced(locator))
+                return [];
+            return authored.ask({ kind: 'replica.wanted', key, locator });
         },
-        async providerLimits() {
-            return (await declaration(database)).providerLimits;
+        async remember(locator, key, paths) {
+            if (fenced(locator) || paths.length === 0)
+                return;
+            await authored.ask({ kind: 'replica.remember', key, locator, paths });
         },
-        async capabilities() {
-            return (await declaration(database)).capabilities;
+        async commit({ rooms, writes = [], files = [], whole = false, discards = [] }) {
+            const kept = whole ? writes : writes.filter(({ locator }) => !fenced(locator));
+            const refused = whole ? kept.find(({ locator }) => fenced(locator)) : undefined;
+            if (refused !== undefined) {
+                return { fenced: refused.locator, counts: {}, changed: {}, indexed: {} };
+            }
+            for (const room of rooms)
+                change(room.key);
+            const committed = await authored.ask({
+                kind: 'replica.commit',
+                ...(kept.length === 0 && files.length === 0 && discards.length === 0
+                    ? {}
+                    : { authored: { writes: rows(kept), files, whole, discards } }),
+                rooms: rooms.filter(({ locator }) => !fenced(locator)),
+            });
+            if (committed.fenced === null || !whole)
+                noted(kept);
+            for (const locator of discards)
+                queued.delete(locator);
+            return committed;
+        },
+        async fence(locators) {
+            await authored.ask({ kind: 'replica.fence', locators });
+            for (const locator of locators)
+                queued.delete(locator);
         },
-        declare(limits, capabilities) {
-            return updateDeclaration(database, (record) => ({
-                ...record,
-                providerLimits: limits,
-                capabilities,
-            }));
+        async erase(locator, limit) {
+            return (await authored.ask({ kind: 'replica.erase', locator, limit })).remaining;
         },
-        async member() {
-            const transaction = database.transaction(DECLARATIONS, 'readonly');
-            const held = await settled(transaction.objectStore(DECLARATIONS).get(MEMBER));
-            return held ?? null;
+        async abandon(locator) {
+            if (fenced(locator))
+                return;
+            await authored.ask({ kind: 'replica.abandon', locator });
+        },
+        async release(key) {
+            await authored.ask({ kind: 'replica.release', key });
+        },
+        async rederive(key, composition, bytes, ms, floor) {
+            change(key);
+            return authored.ask({
+                kind: 'replica.rederive',
+                key,
+                composed: composedOf(composition),
+                bytes,
+                ms,
+                floor,
+            });
         },
-        async keepMember(member) {
-            const transaction = database.transaction(DECLARATIONS, 'readwrite');
-            transaction.objectStore(DECLARATIONS).put(member, MEMBER);
-            await completed(transaction);
+        async fact(name, value) {
+            await authored.ask({ kind: 'replica.fact', name, value: JSON.stringify(value) });
         },
         async queues() {
-            const transaction = authored.transaction([QUEUES, PENDING_CHANGES], 'readonly');
-            const [queues, pending] = await Promise.all([
-                settled(transaction.objectStore(QUEUES).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 queues
                 .filter((queue) => !fenced(queue.locator))
                 .map((queue) => ({
                 locator: queue.locator,
-                pending: queue.order.map((id) => {
+                pending: queue.ids.map((id) => {
                     const record = byId.get(`${queue.locator}\0${id}`);
                     if (record === undefined)
                         throw new Error(`Missing Pending Change ${queue.locator}/${id}`);
-                    const { batch, drafts, submission, lost, upload, accepted } = record;
-                    return { batch, state: { drafts, submission, lost, upload, accepted } };
+                    return {
+                        batch: JSON.parse(record.batch),
+                        state: JSON.parse(record.state),
+                    };
                 }),
             }));
         },
-        async submit(locator, id, submission, lost) {
-            if (!fenced(locator))
-                await amendPending(authored, locator, id, { submission, lost });
+        submit(locator, id, submission, lost) {
+            return amend(locator, id, { submission, lost });
         },
-        async accept(locator, id, roomVersion) {
-            if (!fenced(locator))
-                await amendPending(authored, locator, id, { accepted: roomVersion });
-        },
-        async keepUpload(locator, id, upload) {
-            if (!fenced(locator))
-                await amendPending(authored, locator, id, { upload });
+        keepUpload(locator, id, upload) {
+            return amend(locator, id, { upload });
         },
         async roomDrafts() {
-            const transaction = authored.transaction(ROOM_DRAFTS, 'readonly');
-            const held = await 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());
+            const held = await authored.ask({ kind: 'authored.roomDrafts' });
+            return held
+                .map((record) => JSON.parse(record))
+                .filter((record) => !fenced(record.locator));
         },
         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();
-                };
-            });
-            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({
-                    conversation,
-                    read: read.at,
-                    ...(read.partial ? { partial: true } : {}),
-                });
-            }
-            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
-                        at.continue();
-                };
+            await authored.ask({
+                kind: 'replica.present',
+                app: record.app,
+                value: JSON.stringify(record.value ?? null),
             });
-            return latest.reverse();
-        },
-        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));
-            return held.map(accepted);
-        },
-        async messageIdentities(conversation) {
-            const transaction = database.transaction(MESSAGES, 'readonly');
-            const keys = await 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]));
-            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);
+        conversations() {
+            return authored.ask({ kind: 'conversation.held' });
         },
-        async chatDrafts() {
-            const transaction = authored.transaction(CHAT_DRAFTS, 'readonly');
-            const held = await settled(transaction.objectStore(CHAT_DRAFTS).getAll());
-            return held.map(chatDraftRecord);
+        async keepMessages(write) {
+            await authored.ask({ kind: 'conversation.keep', ...write });
         },
-        async keepChatDraft(record) {
-            const transaction = authored.transaction(CHAT_DRAFTS, 'readwrite');
-            transaction.objectStore(CHAT_DRAFTS).put(record);
-            await completed(transaction);
+        messageWindow(conversation, limit, before, phrase = null) {
+            return authored.ask({ kind: 'conversation.window', conversation, limit, before, phrase });
         },
-        async dropChatDraft(conversation) {
-            const transaction = authored.transaction(CHAT_DRAFTS, 'readwrite');
-            transaction.objectStore(CHAT_DRAFTS).delete(conversation);
-            await completed(transaction);
+        messageCount(conversation, phrase = null) {
+            return authored.ask({ kind: 'conversation.count', conversation, phrase });
         },
-        async keepRoomDraft(record) {
-            if (fenced(record.locator))
-                return;
-            const transaction = authored.transaction(ROOM_DRAFTS, 'readwrite');
-            transaction.objectStore(ROOM_DRAFTS).put(record);
-            await completed(transaction);
+        turnArrived(conversation, turn) {
+            return authored.ask({ kind: 'conversation.turn', conversation, turn });
         },
-        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);
-        },
-        async fences() {
-            const transaction = authored.transaction(FENCES, 'readonly');
-            const held = await 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 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);
+        async dropConversations(conversations) {
+            await authored.ask({ kind: 'conversation.drop', conversations });
         },
-        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);
+        async chatDrafts() {
+            const records = await authored.ask({ kind: 'authored.chatDrafts' });
+            return records.map((record) => JSON.parse(record));
+        },
+        async keepChatDrafts(records) {
+            await authored.ask({
+                kind: 'authored.chatDraft',
+                kept: records.map((record) => ({
+                    conversation: record.conversation,
+                    record: JSON.stringify(record),
+                })),
+                dropped: [],
+            });
         },
-        async transfers() {
-            const transaction = database.transaction(TRANSFERS, 'readonly');
-            const held = await settled(transaction.objectStore(TRANSFERS).getAll());
-            return held.filter((record) => !fenced(record.locator));
+        async dropChatDraft(conversation) {
+            await authored.ask({ kind: 'authored.chatDraft', kept: [], dropped: [conversation] });
+        },
+        async calls() {
+            return restored(await authored.ask({ kind: 'authored.calls' }));
+        },
+        async keepCall(record) {
+            const { stored, ...kept } = keyed(keys, record);
+            await authored.ask({
+                kind: 'authored.call',
+                operation: record.operation,
+                kept,
+                files: stored,
+            });
         },
-        staged(record) {
-            const transaction = database.transaction([DOCUMENTS, BINARY_FILES], 'readonly');
-            return readLayer(transaction, record.locator, record.transfer);
+        async dropCall(operation) {
+            await authored.ask({ kind: 'authored.call', operation, kept: null, files: [] });
         },
-        async stage(record, page) {
+        async keepRoomDraft(record, files) {
             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 { path, ...kept } = roomDraftRow(record);
+            await authored.ask({
+                kind: 'authored.roomDraft',
+                locator: record.locator,
+                path,
+                kept,
+                files,
+            });
         },
-        async abandon(locator) {
+        async discardRoomDraft(locator, path) {
             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);
-        },
-        async receivedHeads() {
-            const transaction = database.transaction(RECEIVED, 'readonly');
-            return settled(transaction.objectStore(RECEIVED).getAll());
-        },
-        async receivedParts(key, count) {
-            const transaction = database.transaction(RECEIVED_PARTS, 'readonly');
-            const kept = await 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) {
-            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);
-        },
-        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 authored.ask({ kind: 'authored.roomDraft', locator, path, kept: null, files: [] });
+        },
+        fences() {
+            return authored.ask({ kind: 'authored.fences' });
         },
-        async generation() {
-            const transaction = authored.transaction(FACTS, 'readonly');
-            const held = await settled(transaction.objectStore(FACTS).get(GENERATION));
-            return held ?? null;
+        generation() {
+            return fact('generation');
         },
         async rememberGeneration(value) {
-            const transaction = authored.transaction(FACTS, 'readwrite');
-            transaction.objectStore(FACTS).put(value, GENERATION);
-            await completed(transaction);
+            await authored.ask({ kind: 'authored.remember', name: 'generation', value });
         },
-        close() {
-            authored.close();
-            database.close();
+        file(key, type) {
+            return authored.ask({ kind: 'authored.file', key, type });
         },
     };
 }