@agentshouse/mdruntime 0.1.0-c967d1ca66fee → 0.1.0-ca14c49c06d90

package/dist/store.js

@@ -1,11 +1,13 @@
-import { transferIdentity } from './identity.js';
-import { sameChange } from './overlay.js';
+import { sameBinary, sameChange } from './overlay.js';
 const DATABASE = 'mdruntime';
+const AUTHORED = 'mdruntime-authored';
+const FENCES = 'fences';
 const ROOMS = 'rooms';
 const DOCUMENTS = 'documents';
-const BINARY_TARGETS = 'binaryTargets';
-const ATTACHMENTS = 'attachments';
+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';
@@ -13,10 +15,36 @@ 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';
-export const STORE_SCHEMA = 21;
-const PATH_KEYED_SCHEMA = 20;
+const GENERATION = 'generation';
+const HOLDER = 'holder';
+const BINDING = 'binding';
+export const STORE_SCHEMA = 24;
+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;
 function settled(request) {
     return new Promise((resolve, reject) => {
@@ -33,7 +61,6 @@ function completed(transaction) {
 }
 const EMPTY_DECLARATIONS = {
     lastCompleted: null,
-    generation: null,
     providerLimits: [],
     capabilities: [],
 };
@@ -61,9 +88,12 @@ function amendPending(database, locator, id, amendment) {
     };
     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 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
@@ -85,7 +115,7 @@ async function readTransfer(store, locator, transfer, receive) {
     }
 }
 function emptyLayer() {
-    return { documents: {}, binaryTargets: [], revisions: {}, changes: {}, written: {} };
+    return { documents: {}, binaries: {}, revisions: {}, changes: {}, written: {} };
 }
 async function readLayer(transaction, locator, transfer) {
     const layer = emptyLayer();
@@ -101,9 +131,9 @@ async function readLayer(transaction, locator, transfer) {
             layer.written[document.path] = document.written;
         head(document);
     });
-    await readTransfer(transaction.objectStore(BINARY_TARGETS), locator, transfer, (target) => {
-        layer.binaryTargets.push(target.path);
-        head(target);
+    await readTransfer(transaction.objectStore(BINARY_FILES), locator, transfer, (file) => {
+        layer.binaries[file.path] = file.binary;
+        head(file);
     });
     return layer;
 }
@@ -118,13 +148,14 @@ function documentRecord(locator, transfer, layer, path) {
         written: layer.written[path] ?? null,
     };
 }
-function targetRecord(locator, transfer, layer, path) {
+function binaryFileRecord(locator, transfer, layer, path) {
     return {
         locator,
         transfer,
         path,
         revision: layer.revisions[path] ?? null,
         change: layer.changes[path] ?? null,
+        binary: layer.binaries[path],
     };
 }
 function writeLayer(transaction, locator, transfer, next, base) {
@@ -141,18 +172,16 @@ function writeLayer(transaction, locator, transfer, next, base) {
             continue;
         documents.put(documentRecord(locator, transfer, next, path));
     }
-    const targets = transaction.objectStore(BINARY_TARGETS);
-    const beforeTargets = new Set(base?.binaryTargets ?? []);
-    const afterTargets = new Set(next.binaryTargets);
-    for (const path of beforeTargets) {
-        if (!afterTargets.has(path))
-            targets.delete([locator, transfer, 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 afterTargets) {
-        if (!beforeTargets.has(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])) {
-            targets.put(targetRecord(locator, transfer, next, path));
+            files.put(binaryFileRecord(locator, transfer, next, path));
         }
     }
 }
@@ -165,155 +194,182 @@ function removeRoomEntries(store, locator) {
         }
     };
 }
-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);
     });
 }
-function keyByTransfer(database, upgrade) {
-    database.createObjectStore(TRANSFERS, { keyPath: 'locator' });
-    const moves = [DOCUMENTS, BINARY_TARGETS].map((name) => {
-        const from = upgrade.objectStore(name);
-        from.name = `${name}-${PATH_KEYED_SCHEMA}`;
-        return {
-            from,
-            to: database.createObjectStore(name, { keyPath: ['locator', 'transfer', 'path'] }),
+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;
         };
-    });
-    const transfers = new Map();
-    const rooms = upgrade.objectStore(ROOMS).openCursor();
-    rooms.onsuccess = () => {
-        const room = rooms.result;
-        if (room !== null) {
-            const record = room.value;
-            const transfer = transferIdentity();
-            transfers.set(record.locator, transfer);
-            room.update({ ...record, transfer });
-            room.continue();
-            return;
+        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();
+    }
+}
+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 = (event) => {
+        const database = opening.result;
+        if (event.oldVersion < REPLICA_SHAPE) {
+            for (const name of [...database.objectStoreNames])
+                database.deleteObjectStore(name);
         }
-        for (const { from, to } of moves) {
-            const held = from.openCursor();
-            held.onsuccess = () => {
-                const entry = held.result;
-                if (entry === null) {
-                    database.deleteObjectStore(from.name);
-                    return;
-                }
-                const record = entry.value;
-                const transfer = transfers.get(record.locator);
-                if (transfer !== undefined)
-                    to.put({ ...record, transfer });
-                entry.continue();
-            };
+        for (const [name, parameters] of REPLICA_STORES) {
+            if (database.objectStoreNames.contains(name))
+                continue;
+            const store = database.createObjectStore(name, parameters);
+            if (name === MESSAGES)
+                store.createIndex('conversation', 'conversation');
         }
     };
+    return settled(opening);
 }
-export async function openRuntimeStore() {
-    const opening = indexedDB.open(DATABASE, STORE_SCHEMA);
-    opening.onupgradeneeded = (event) => {
+function openAuthored() {
+    const opening = indexedDB.open(AUTHORED, AUTHORED_SCHEMA);
+    opening.onupgradeneeded = () => {
         const database = opening.result;
-        if (event.oldVersion === PATH_KEYED_SCHEMA && opening.transaction !== null) {
-            keyByTransfer(database, opening.transaction);
-            return;
+        for (const [name, parameters] of AUTHORED_STORES) {
+            if (!database.objectStoreNames.contains(name))
+                database.createObjectStore(name, parameters);
         }
-        for (const name of [...database.objectStoreNames])
-            database.deleteObjectStore(name);
-        database.createObjectStore(ROOMS, { keyPath: 'locator' });
-        database.createObjectStore(DOCUMENTS, { keyPath: ['locator', 'transfer', 'path'] });
-        database.createObjectStore(BINARY_TARGETS, { keyPath: ['locator', 'transfer', 'path'] });
-        database.createObjectStore(TRANSFERS, { keyPath: 'locator' });
-        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'],
-        });
-        messages.createIndex('conversation', 'conversation');
-        database.createObjectStore(CHAT_DRAFTS, { keyPath: 'conversation' });
     };
-    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([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS], 'readonly');
-            const [rooms, attachments] = await Promise.all([
-                settled(transaction.objectStore(ROOMS).getAll()),
-                settled(transaction.objectStore(ATTACHMENTS).getAll()),
-            ]);
+            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_FILES], 'readonly');
+            const rooms = await settled(transaction.objectStore(ROOMS).getAll());
             const records = [];
-            for (const { order, ...room } of rooms) {
-                const layer = await readLayer(transaction, room.locator, room.transfer);
-                records.push({
-                    ...room,
-                    ...layer,
-                    attachments: attachments.flatMap(({ locator, ...attachment }) => locator === room.locator ? [attachment] : []),
-                });
+            for (const room of rooms.filter((held) => !fenced(held.locator))) {
+                records.push({ ...room, ...(await readLayer(transaction, room.locator, room.transfer)) });
             }
             return records;
         },
-        async write({ next, previous, stored, queue, previousQueue, saved, roomDrafts, consumedRoomDrafts, }) {
-            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, TRANSFERS, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
-            transaction.objectStore(ROOMS).put(roomRecord(next, queue));
-            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_TARGETS).delete(range);
-            }
-            if (moved)
-                transaction.objectStore(TRANSFERS).delete(next.locator);
-            writeLayer(transaction, next.locator, next.transfer, next, moved ? (stored ?? null) : previous);
-            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));
+        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([next.locator, id]);
+                        pending.delete([locator, id]);
                 }
                 for (const batch of queue) {
                     if (!before.has(batch.id)) {
                         pending.put({
-                            locator: next.locator,
+                            locator,
                             id: batch.id,
                             batch,
-                            drafts: saved ?? [],
+                            drafts: saved?.get(batch.id) ?? [],
                             submission: { state: 'waiting' },
                             lost: false,
                         });
                     }
                 }
-            }
+            };
             const draftStore = transaction.objectStore(ROOM_DRAFTS);
             for (const path of consumedRoomDrafts ?? [])
-                draftStore.delete([next.locator, path]);
+                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, queue } of records) {
-                rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }, queue));
+            for (const record of records) {
+                if (fenced(record.locator))
+                    continue;
+                rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }));
             }
             await completed(transaction);
         },
@@ -347,35 +403,41 @@ export async function openRuntimeStore() {
             await completed(transaction);
         },
         async queues() {
-            const transaction = database.transaction([ROOMS, PENDING_CHANGES], 'readonly');
-            const [rooms, pending] = await Promise.all([
-                settled(transaction.objectStore(ROOMS).getAll()),
+            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 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.order.map((id) => {
+                    const record = byId.get(`${queue.locator}\0${id}`);
                     if (record === undefined)
-                        throw new Error(`Missing Pending Change ${room.locator}/${id}`);
+                        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 } };
                 }),
             }));
         },
-        submit(locator, id, submission, lost) {
-            return amendPending(database, locator, id, { submission, lost });
+        async submit(locator, id, submission, lost) {
+            if (!fenced(locator))
+                await amendPending(authored, locator, id, { submission, lost });
         },
-        accept(locator, id, roomVersion) {
-            return amendPending(database, locator, id, { accepted: roomVersion });
+        async accept(locator, id, roomVersion) {
+            if (!fenced(locator))
+                await amendPending(authored, locator, id, { accepted: roomVersion });
         },
-        keepUpload(locator, id, upload) {
-            return amendPending(database, locator, id, { upload });
+        async keepUpload(locator, id, upload) {
+            if (!fenced(locator))
+                await amendPending(authored, locator, id, { upload });
         },
         async roomDrafts() {
-            const transaction = database.transaction(ROOM_DRAFTS, 'readonly');
-            return settled(transaction.objectStore(ROOM_DRAFTS).getAll());
+            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');
@@ -403,8 +465,8 @@ export async function openRuntimeStore() {
             }
             return [...held.values()];
         },
-        async keepMessages({ conversation, messages, read, sealed }) {
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES, CHAT_DRAFTS], 'readwrite');
+        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 });
@@ -414,16 +476,17 @@ export async function openRuntimeStore() {
                     .objectStore(CONVERSATIONS)
                     .put({ conversation, read });
             }
-            if (sealed === true)
-                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
             await completed(transaction);
         },
         async dropConversations(conversations) {
-            const transaction = database.transaction([CONVERSATIONS, MESSAGES, CHAT_DRAFTS], 'readwrite');
+            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);
-                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
                 const keys = messages.index('conversation').getAllKeys(conversation);
                 keys.onsuccess = () => {
                     for (const key of keys.result)
@@ -433,58 +496,83 @@ export async function openRuntimeStore() {
             await completed(transaction);
         },
         async chatDrafts() {
-            const transaction = database.transaction(CHAT_DRAFTS, 'readonly');
-            return settled(transaction.objectStore(CHAT_DRAFTS).getAll());
+            const transaction = authored.transaction(CHAT_DRAFTS, 'readonly');
+            const held = await settled(transaction.objectStore(CHAT_DRAFTS).getAll());
+            return held.map(chatDraftRecord);
         },
         async keepChatDraft(record) {
-            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
+            const transaction = authored.transaction(CHAT_DRAFTS, 'readwrite');
             transaction.objectStore(CHAT_DRAFTS).put(record);
             await completed(transaction);
         },
         async dropChatDraft(conversation) {
-            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
+            const transaction = authored.transaction(CHAT_DRAFTS, 'readwrite');
             transaction.objectStore(CHAT_DRAFTS).delete(conversation);
             await completed(transaction);
         },
         async keepRoomDraft(record) {
-            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
+            if (fenced(record.locator))
+                return;
+            const transaction = authored.transaction(ROOM_DRAFTS, 'readwrite');
             transaction.objectStore(ROOM_DRAFTS).put(record);
             await completed(transaction);
         },
         async discardRoomDraft(locator, path) {
-            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
+            if (fenced(locator))
+                return;
+            const transaction = authored.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, TRANSFERS, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
+        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_TARGETS).delete(underRoom(locator));
-                for (const name of [ATTACHMENTS, PENDING_CHANGES, ROOM_DRAFTS]) {
-                    removeRoomEntries(transaction.objectStore(name), 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');
-            return settled(transaction.objectStore(TRANSFERS).getAll());
+            const held = await settled(transaction.objectStore(TRANSFERS).getAll());
+            return held.filter((record) => !fenced(record.locator));
         },
         staged(record) {
-            const transaction = database.transaction([DOCUMENTS, BINARY_TARGETS], 'readonly');
+            const transaction = database.transaction([DOCUMENTS, BINARY_FILES], 'readonly');
             return readLayer(transaction, record.locator, record.transfer);
         },
         async stage(record, page) {
-            const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_TARGETS], 'readwrite');
+            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 abandon(locator) {
-            const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_TARGETS], 'readwrite');
+            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 = () => {
@@ -494,17 +582,48 @@ export async function openRuntimeStore() {
                 transfers.delete(locator);
                 const range = underTransfer(locator, record.transfer);
                 transaction.objectStore(DOCUMENTS).delete(range);
-                transaction.objectStore(BINARY_TARGETS).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);
+        },
         async generation() {
-            return (await declaration(database)).generation;
+            const transaction = authored.transaction(FACTS, 'readonly');
+            const held = await settled(transaction.objectStore(FACTS).get(GENERATION));
+            return held ?? null;
         },
-        rememberGeneration(value) {
-            return updateDeclaration(database, (record) => ({ ...record, generation: value }));
+        async rememberGeneration(value) {
+            const transaction = authored.transaction(FACTS, 'readwrite');
+            transaction.objectStore(FACTS).put(value, GENERATION);
+            await completed(transaction);
         },
         close() {
+            authored.close();
             database.close();
         },
     };