@agentshouse/mdruntime 0.1.0-alpha.9 → 0.1.0-c0105dbd22806

package/dist/store.js

@@ -1,191 +1,572 @@
+import { sameBinary, sameChange } from './overlay.js';
 const DATABASE = 'mdruntime';
-const REPLICAS = 'replicas';
-const SYNCHRONIZATION = 'synchronization';
-const DISCOVERY = 'discovery';
-const QUEUES = 'queues';
-const DRAFTS = 'drafts';
+const AUTHORED = 'mdruntime-authored';
+const FENCES = 'fences';
+const ROOMS = 'rooms';
+const DOCUMENTS = 'documents';
+const BINARY_FILES = 'binaryFiles';
+const TRANSFERS = 'transfers';
+const PENDING_CHANGES = 'pendingChanges';
+const DECLARATIONS = 'declarations';
+const ROOM_DRAFTS = 'roomDrafts';
 const PRESENTATION = 'presentation';
 const CONVERSATIONS = 'conversations';
-const INSTRUCTIONS = 'instructions';
-const LAST_COMPLETED = 'lastCompleted';
+const MESSAGES = 'messages';
+const CHAT_DRAFTS = 'chatDrafts';
+const QUEUES = 'queues';
+const FACTS = 'facts';
+const CURRENT = 'current';
+const MEMBER = 'member';
 const GENERATION = 'generation';
-const PROVIDER_LIMITS = 'providerLimits';
-const SCHEMA = 8;
+const HOLDER = 'holder';
+export const STORE_SCHEMA = 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 READ_BATCH = 256;
 function settled(request) {
-    return new Promise((resolve, reject)=>{
-        request.onsuccess = ()=>resolve(request.result);
-        request.onerror = ()=>reject(request.error);
+    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);
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error);
+        transaction.onabort = () => reject(transaction.error);
     });
 }
-export function removeRuntimeStore() {
-    return new Promise((resolve, reject)=>{
-        const removal = indexedDB.deleteDatabase(DATABASE);
-        removal.onsuccess = ()=>resolve();
-        removal.onerror = ()=>reject(removal.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 roomRecord(record) {
+    const { documents, binaries, revisions, changes, written, ...room } = record;
+    return room;
+}
+function chatDraftRecord(record) {
+    return { ...record, revision: record.revision ?? '' };
+}
+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: {}, 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.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 discardEveryEarlierStore(database) {
-    for (const name of [
-        ...database.objectStoreNames
-    ])database.deleteObjectStore(name);
+function documentRecord(locator, transfer, layer, path) {
+    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],
+    };
 }
-export async function openRuntimeStore() {
-    const opening = indexedDB.open(DATABASE, SCHEMA);
-    opening.onupgradeneeded = ()=>{
+function writeLayer(transaction, locator, transfer, next, base) {
+    const documents = transaction.objectStore(DOCUMENTS);
+    for (const path of Object.keys(base?.documents ?? {})) {
+        if (next.documents[path] === undefined)
+            documents.delete([locator, transfer, path]);
+    }
+    for (const [path, content] of Object.entries(next.documents)) {
+        if (base?.documents[path] === content &&
+            base.revisions[path] === next.revisions[path] &&
+            base.written[path] === next.written[path] &&
+            sameChange(base.changes[path], next.changes[path]))
+            continue;
+        documents.put(documentRecord(locator, transfer, next, path));
+    }
+    const files = transaction.objectStore(BINARY_FILES);
+    for (const path of Object.keys(base?.binaries ?? {})) {
+        if (next.binaries[path] === undefined)
+            files.delete([locator, transfer, path]);
+    }
+    for (const path of Object.keys(next.binaries)) {
+        if (!sameBinary(base?.binaries[path], next.binaries[path]) ||
+            base?.revisions[path] !== next.revisions[path] ||
+            !sameChange(base?.changes[path], next.changes[path])) {
+            files.put(binaryFileRecord(locator, transfer, next, 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 removeDatabase(name) {
+    return new Promise((resolve, reject) => {
+        const removal = indexedDB.deleteDatabase(name);
+        removal.onsuccess = () => resolve();
+        removal.onerror = () => reject(removal.error);
+    });
+}
+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 removeRuntimeStore(holder) {
+    await removeDatabase(DATABASE);
+    if (holder !== undefined && (await authoredBy(holder)))
+        return true;
+    await removeDatabase(AUTHORED);
+    return false;
+}
+function openReplica() {
+    const opening = indexedDB.open(DATABASE, STORE_SCHEMA);
+    opening.onupgradeneeded = () => {
         const database = opening.result;
-        discardEveryEarlierStore(database);
-        database.createObjectStore(REPLICAS, {
-            keyPath: 'locator'
-        });
-        database.createObjectStore(SYNCHRONIZATION);
-        database.createObjectStore(DISCOVERY);
-        database.createObjectStore(QUEUES, {
-            keyPath: 'locator'
-        });
-        database.createObjectStore(DRAFTS, {
-            keyPath: [
-                'locator',
-                'path'
-            ]
-        });
-        database.createObjectStore(PRESENTATION, {
-            keyPath: 'app'
-        });
-        database.createObjectStore(CONVERSATIONS, {
-            keyPath: 'conversation'
-        });
-        database.createObjectStore(INSTRUCTIONS, {
-            keyPath: 'conversation'
+        for (const name of [...database.objectStoreNames])
+            database.deleteObjectStore(name);
+        database.createObjectStore(ROOMS, { keyPath: 'locator' });
+        database.createObjectStore(DOCUMENTS, { keyPath: ['locator', 'transfer', 'path'] });
+        database.createObjectStore(BINARY_FILES, { keyPath: ['locator', 'transfer', 'path'] });
+        database.createObjectStore(TRANSFERS, { keyPath: 'locator' });
+        database.createObjectStore(DECLARATIONS);
+        database.createObjectStore(PRESENTATION, { keyPath: 'app' });
+        database.createObjectStore(CONVERSATIONS, { keyPath: 'conversation' });
+        const messages = database.createObjectStore(MESSAGES, {
+            keyPath: ['conversation', 'identity'],
         });
+        messages.createIndex('conversation', 'conversation');
+    };
+    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 database = await settled(opening);
+    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(REPLICAS, 'readonly');
-            return settled(transaction.objectStore(REPLICAS).getAll());
+        async all() {
+            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_FILES], 'readonly');
+            const rooms = await settled(transaction.objectStore(ROOMS).getAll());
+            const records = [];
+            for (const room of rooms.filter((held) => !fenced(held.locator))) {
+                records.push({ ...room, ...(await readLayer(transaction, room.locator, room.transfer)) });
+            }
+            return records;
         },
-        async publish (record) {
-            const transaction = database.transaction(REPLICAS, 'readwrite');
-            transaction.objectStore(REPLICAS).put(record);
+        async keepAuthored({ locator, queue, saved, roomDrafts, consumedRoomDrafts }) {
+            if (fenced(locator))
+                return;
+            const transaction = authored.transaction([QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
+            const order = transaction.objectStore(QUEUES);
+            const pending = transaction.objectStore(PENDING_CHANGES);
+            const held = order.get(locator);
+            held.onsuccess = () => {
+                const before = new Set(held.result?.order ?? []);
+                const after = new Set(queue.map((batch) => batch.id));
+                if (queue.length === 0)
+                    order.delete(locator);
+                else
+                    order.put({ locator, order: [...after] });
+                for (const id of before) {
+                    if (!after.has(id))
+                        pending.delete([locator, id]);
+                }
+                for (const batch of queue) {
+                    if (!before.has(batch.id)) {
+                        pending.put({
+                            locator,
+                            id: batch.id,
+                            batch,
+                            drafts: saved?.get(batch.id) ?? [],
+                            submission: { state: 'waiting' },
+                            lost: false,
+                        });
+                    }
+                }
+            };
+            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 lastCompleted () {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readonly');
-            const value = await settled(transaction.objectStore(SYNCHRONIZATION).get(LAST_COMPLETED));
-            return value ?? null;
+        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 complete (at) {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readwrite');
-            transaction.objectStore(SYNCHRONIZATION).put(at, LAST_COMPLETED);
+        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);
         },
-        async providerLimits () {
-            const transaction = database.transaction(DISCOVERY, 'readonly');
-            const value = await settled(transaction.objectStore(DISCOVERY).get(PROVIDER_LIMITS));
-            return value ?? [];
+        async lastCompleted() {
+            return (await declaration(database)).lastCompleted;
+        },
+        complete(at) {
+            return updateDeclaration(database, (record) => ({ ...record, lastCompleted: at }));
+        },
+        async providerLimits() {
+            return (await declaration(database)).providerLimits;
+        },
+        async capabilities() {
+            return (await declaration(database)).capabilities;
+        },
+        declare(limits, capabilities) {
+            return updateDeclaration(database, (record) => ({
+                ...record,
+                providerLimits: limits,
+                capabilities,
+            }));
         },
-        async declare (limits) {
-            const transaction = database.transaction(DISCOVERY, 'readwrite');
-            transaction.objectStore(DISCOVERY).put(limits, PROVIDER_LIMITS);
+        async member() {
+            const transaction = database.transaction(DECLARATIONS, 'readonly');
+            const held = await settled(transaction.objectStore(DECLARATIONS).get(MEMBER));
+            return held ?? null;
+        },
+        async keepMember(member) {
+            const transaction = database.transaction(DECLARATIONS, 'readwrite');
+            transaction.objectStore(DECLARATIONS).put(member, MEMBER);
             await completed(transaction);
         },
-        async queues () {
-            const transaction = database.transaction(QUEUES, 'readonly');
-            return settled(transaction.objectStore(QUEUES).getAll());
+        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 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) => {
+                    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 } };
+                }),
+            }));
+        },
+        async submit(locator, id, submission, lost) {
+            if (!fenced(locator))
+                await amendPending(authored, locator, id, { submission, lost });
+        },
+        async accept(locator, id, roomVersion) {
+            if (!fenced(locator))
+                await amendPending(authored, locator, id, { accepted: roomVersion });
         },
-        async drafts () {
-            const transaction = database.transaction(DRAFTS, 'readonly');
-            return settled(transaction.objectStore(DRAFTS).getAll());
+        async keepUpload(locator, id, upload) {
+            if (!fenced(locator))
+                await amendPending(authored, locator, id, { upload });
         },
-        async presentation () {
+        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());
         },
-        async present (record) {
+        async present(record) {
             const transaction = database.transaction(PRESENTATION, 'readwrite');
             transaction.objectStore(PRESENTATION).put(record);
             await completed(transaction);
         },
-        async conversations () {
-            const transaction = database.transaction(CONVERSATIONS, 'readonly');
-            return settled(transaction.objectStore(CONVERSATIONS).getAll());
+        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()];
         },
-        async keepConversation (record) {
-            const transaction = database.transaction(CONVERSATIONS, 'readwrite');
-            transaction.objectStore(CONVERSATIONS).put(record);
+        async keepMessages({ conversation, messages, read, sealed }) {
+            if (sealed === true) {
+                const sealing = authored.transaction(CHAT_DRAFTS, 'readwrite');
+                sealing.objectStore(CHAT_DRAFTS).delete(conversation);
+                await completed(sealing);
+            }
+            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 });
+            }
             await completed(transaction);
         },
-        async dropConversation (conversation) {
-            const transaction = database.transaction(CONVERSATIONS, 'readwrite');
-            transaction.objectStore(CONVERSATIONS).delete(conversation);
+        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);
         },
-        async instructions () {
-            const transaction = database.transaction(INSTRUCTIONS, 'readonly');
-            return settled(transaction.objectStore(INSTRUCTIONS).getAll());
+        async chatDrafts() {
+            const transaction = authored.transaction(CHAT_DRAFTS, 'readonly');
+            const held = await settled(transaction.objectStore(CHAT_DRAFTS).getAll());
+            return held.map(chatDraftRecord);
         },
-        async keepInstruction (record) {
-            const transaction = database.transaction(INSTRUCTIONS, 'readwrite');
-            transaction.objectStore(INSTRUCTIONS).put(record);
+        async keepChatDraft(record) {
+            const transaction = authored.transaction(CHAT_DRAFTS, 'readwrite');
+            transaction.objectStore(CHAT_DRAFTS).put(record);
             await completed(transaction);
         },
-        async dropInstruction (conversation) {
-            const transaction = database.transaction(INSTRUCTIONS, 'readwrite');
-            transaction.objectStore(INSTRUCTIONS).delete(conversation);
+        async dropChatDraft(conversation) {
+            const transaction = authored.transaction(CHAT_DRAFTS, 'readwrite');
+            transaction.objectStore(CHAT_DRAFTS).delete(conversation);
             await completed(transaction);
         },
-        async keep (draft) {
-            const transaction = database.transaction(DRAFTS, 'readwrite');
-            transaction.objectStore(DRAFTS).put(draft);
+        async keepRoomDraft(record) {
+            if (fenced(record.locator))
+                return;
+            const transaction = authored.transaction(ROOM_DRAFTS, 'readwrite');
+            transaction.objectStore(ROOM_DRAFTS).put(record);
             await completed(transaction);
         },
-        async discard (locator, path) {
-            const transaction = database.transaction(DRAFTS, 'readwrite');
-            transaction.objectStore(DRAFTS).delete([
-                locator,
-                path
-            ]);
+        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 append (queue, consumed) {
-            const transaction = database.transaction([
-                QUEUES,
-                DRAFTS
-            ], 'readwrite');
-            transaction.objectStore(QUEUES).put(queue);
-            const drafts = transaction.objectStore(DRAFTS);
-            for (const path of consumed)drafts.delete([
-                queue.locator,
-                path
-            ]);
+        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 transfers() {
+            const transaction = database.transaction(TRANSFERS, 'readonly');
+            const held = await settled(transaction.objectStore(TRANSFERS).getAll());
+            return held.filter((record) => !fenced(record.locator));
         },
-        async writeQueue (queue) {
-            const transaction = database.transaction(QUEUES, 'readwrite');
-            transaction.objectStore(QUEUES).put(queue);
+        staged(record) {
+            const transaction = database.transaction([DOCUMENTS, BINARY_FILES], 'readonly');
+            return readLayer(transaction, record.locator, record.transfer);
+        },
+        async stage(record, page) {
+            if (fenced(record.locator))
+                return;
+            const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite');
+            writeLayer(transaction, record.locator, record.transfer, page, null);
+            transaction.objectStore(TRANSFERS).put(record);
             await completed(transaction);
         },
-        async generation () {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readonly');
-            const value = await settled(transaction.objectStore(SYNCHRONIZATION).get(GENERATION));
-            return value ?? null;
+        async abandon(locator) {
+            if (fenced(locator))
+                return;
+            const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite');
+            const transfers = transaction.objectStore(TRANSFERS);
+            const held = transfers.get(locator);
+            held.onsuccess = () => {
+                const record = held.result;
+                if (record === undefined)
+                    return;
+                transfers.delete(locator);
+                const range = underTransfer(locator, record.transfer);
+                transaction.objectStore(DOCUMENTS).delete(range);
+                transaction.objectStore(BINARY_FILES).delete(range);
+            };
+            await completed(transaction);
         },
-        async rememberGeneration (value) {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readwrite');
-            transaction.objectStore(SYNCHRONIZATION).put(value, GENERATION);
+        async generation() {
+            const transaction = authored.transaction(FACTS, 'readonly');
+            const held = await settled(transaction.objectStore(FACTS).get(GENERATION));
+            return held ?? null;
+        },
+        async rememberGeneration(value) {
+            const transaction = authored.transaction(FACTS, 'readwrite');
+            transaction.objectStore(FACTS).put(value, GENERATION);
             await completed(transaction);
         },
-        close () {
+        close() {
+            authored.close();
             database.close();
-        }
+        },
     };
 }
-
-//# sourceMappingURL=store.js.map