@agentshouse/mdruntime 0.1.0-caee7332d2235 → 0.1.0-caf080a9a9c60

package/dist/store.js

@@ -1,816 +1,177 @@
-import { sameBinary, sameChange } from './overlay.js';
-import { differences } from './shared.js';
-import { inUnits, ROW_WEIGHT, stepped } from './turn.js';
-import { precedes } from './windows.js';
-const DATABASE = 'mdruntime';
-const AUTHORED = 'mdruntime-authored';
-const FENCES = 'fences';
-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 CALLS = 'calls';
-const QUEUES = 'queues';
-const FACTS = 'facts';
-const CURRENT = 'current';
-const MEMBER = 'member';
-const TARGETS = 'targets';
-const GENERATION = 'generation';
-const HOLDER = 'holder';
-const BINDING = 'binding';
-export const STORE_SCHEMA = 25;
-const REPLICA_SHAPE = 23;
-export const AUTHORED_SCHEMA = 3;
-const AUTHORED_STORES = [
-    [QUEUES, { keyPath: 'locator' }],
-    [PENDING_CHANGES, { keyPath: ['locator', 'id'] }],
-    [ROOM_DRAFTS, { keyPath: ['locator', 'path'] }],
-    [CHAT_DRAFTS, { keyPath: 'conversation' }],
-    [CALLS, { keyPath: 'operation' }],
-    [FACTS, undefined],
-    [FENCES, { keyPath: 'locator' }],
-];
-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);
+import { schemaTypes } from './attached-model.js';
+import { createCell } from './cell.js';
+import { openedFiles } from './opened.js';
+import { compositionOf } from './replica.js';
+import { STARTING } from './status.js';
+import { createInstalls, NO_INSTALL } from './store/installs.js';
+import { openRuntimeStore, } from './store/records.js';
+import { createReadinessQueue } from './store/readiness.js';
+import { createRoomHeld } from './store/room-held.js';
+import { createSpace } from './store/space.js';
+import { createWatchers } from './store/watchers.js';
+import { createWrites } from './store/writes.js';
+const OPENING = 'store';
+export function createStore(options) {
+    const writes = createWrites();
+    const watchers = createWatchers(options.unpublished);
+    const { lost } = options;
+    const installs = createInstalls();
+    const seeds = new Map();
+    const landed = createRoomHeld();
+    const attached = createRoomHeld();
+    const typesHeld = new Map();
+    const device = createCell({
+        persistence: options.persistence,
+        storageLoss: null,
+        heldWhenOpened: false,
+        preparing: false,
+        sweeping: false,
+        unpreparedDemand: new Set(),
+        unpreparable: new Set(),
+        establishing: new Set(),
+        status: STARTING,
+        roomsShown: null,
     });
-}
-const turns = new Map();
-function idle(database) {
-    return turns.get(database.name) ?? Promise.resolve();
-}
-export function transacted(database, stores, mode, work) {
-    let release = () => { };
-    const turn = new Promise((resolve) => {
-        release = resolve;
-    });
-    const before = idle(database);
-    const queued = before.then(() => turn);
-    turns.set(database.name, queued);
-    void queued.then(() => {
-        if (turns.get(database.name) === queued)
-            turns.delete(database.name);
-    });
-    return before.then(() => {
-        let transaction;
-        try {
-            transaction = database.transaction(stores, mode);
-        }
-        catch (error) {
-            release();
+    const space = createSpace(options.database, options.spaceFreed);
+    const readiness = createReadinessQueue(options.deliverReadiness, options.unpublished);
+    let opening;
+    function open() {
+        opening ??= options.opening(openRuntimeStore(options.database)).then((opened) => {
+            options.retries.succeeded('database', OPENING);
+            return opened;
+        }, (error) => {
+            opening = undefined;
+            options.retries.failed('database', OPENING, error);
             throw error;
-        }
-        const committed = new Promise((resolve, reject) => {
-            transaction.oncomplete = () => {
-                release();
-                resolve();
-            };
-            transaction.onabort = () => {
-                release();
-                reject(transaction.error);
-            };
-            transaction.onerror = () => reject(transaction.error);
         });
-        let value;
-        try {
-            value = work(transaction);
-        }
-        catch (error) {
-            void committed.catch(() => { });
-            transaction.abort();
-            throw error;
-        }
-        return Promise.all([value, committed]).then(([held]) => held);
-    });
-}
-const EMPTY_DECLARATIONS = {
-    lastCompleted: null,
-    providerLimits: [],
-    capabilities: [],
-};
-function declaration(database) {
-    return transacted(database, DECLARATIONS, 'readonly', (transaction) => settled(transaction.objectStore(DECLARATIONS).get(CURRENT))).then((record) => record ?? EMPTY_DECLARATIONS);
-}
-function updateDeclaration(database, update) {
-    return transacted(database, DECLARATIONS, 'readwrite', (transaction) => {
-        const store = transaction.objectStore(DECLARATIONS);
-        const prior = store.get(CURRENT);
-        prior.onsuccess = () => {
-            store.put(update(prior.result ?? EMPTY_DECLARATIONS), CURRENT);
-        };
-    });
-}
-function amendPending(database, locator, id, amendment) {
-    return transacted(database, PENDING_CHANGES, 'readwrite', (transaction) => {
-        const pending = transaction.objectStore(PENDING_CHANGES);
-        const request = pending.get([locator, id]);
-        request.onsuccess = () => {
-            const record = request.result;
-            if (record !== undefined)
-                pending.put({ ...record, ...amendment });
-        };
-    });
-}
-function accepted({ conversation: _held, ...message }) {
-    return message;
-}
-function roomRecord(record) {
-    const { documents, binaries, revisions, fileIds, 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);
+        return opening;
     }
-}
-function emptyLayer() {
-    return { documents: {}, binaries: {}, revisions: {}, fileIds: {}, changes: {}, written: {} };
-}
-async function readLayer(transaction, locator, transfer) {
-    const layer = emptyLayer();
-    const head = (held) => {
-        if (held.revision !== null)
-            layer.revisions[held.path] = held.revision;
-        if (held.fileId !== null)
-            layer.fileIds[held.path] = held.fileId;
-        if (held.change !== null)
-            layer.changes[held.path] = held.change;
-    };
-    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) {
-    return {
-        locator,
-        transfer,
-        path,
-        content: layer.documents[path],
-        revision: layer.revisions[path] ?? null,
-        fileId: layer.fileIds[path] ?? null,
-        change: layer.changes[path] ?? null,
-        written: layer.written[path] ?? null,
-    };
-}
-function binaryFileRecord(locator, transfer, layer, path) {
-    return {
-        locator,
-        transfer,
-        path,
-        revision: layer.revisions[path] ?? null,
-        fileId: layer.fileIds[path] ?? null,
-        change: layer.changes[path] ?? null,
-        binary: layer.binaries[path],
-    };
-}
-function* changedIn(next, base) {
-    if (base === null)
-        return new Set([...Object.keys(next.documents), ...Object.keys(next.binaries)]);
-    return new Set([
-        ...(yield* differences(base.documents, next.documents)),
-        ...(yield* differences(base.revisions, next.revisions)),
-        ...(yield* differences(base.fileIds, next.fileIds)),
-        ...(yield* differences(base.written, next.written)),
-        ...(yield* differences(base.changes, next.changes, sameChange)),
-        ...(yield* differences(base.binaries, next.binaries, sameBinary)),
-    ]);
-}
-function writeLayer(transaction, locator, transfer, layer) {
-    const { next, base, paths } = layer;
-    const documents = transaction.objectStore(DOCUMENTS);
-    const files = transaction.objectStore(BINARY_FILES);
-    let last = null;
-    return inUnits(paths, (path) => {
-        if (next.documents[path] !== undefined) {
-            last = documents.put(documentRecord(locator, transfer, next, path));
-        }
-        else if (base?.documents[path] !== undefined) {
-            last = documents.delete([locator, transfer, path]);
-        }
-        if (next.binaries[path] !== undefined) {
-            last = files.put(binaryFileRecord(locator, transfer, next, path));
-        }
-        else if (base?.binaries[path] !== undefined) {
-            last = files.delete([locator, transfer, path]);
-        }
-        return ROW_WEIGHT + (next.documents[path]?.length ?? 0);
-    }, () => { }, () => {
-        const request = last;
-        last = null;
-        return request === null
-            ? Promise.resolve()
-            : new Promise((resolve) => request.addEventListener('success', () => resolve()));
-    });
-}
-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 held = await transacted(authored, FACTS, 'readonly', (transaction) => settled(transaction.objectStore(FACTS).get(HOLDER)));
-        return typeof held === 'string' ? held : null;
-    }
-    finally {
-        authored.close();
-    }
-}
-export async function authoredBy(holder) {
-    const authored = await openAuthored();
-    try {
-        let owned = true;
-        await transacted(authored, FACTS, 'readwrite', (transaction) => {
-            const facts = transaction.objectStore(FACTS);
-            const held = facts.get(HOLDER);
-            held.onsuccess = () => {
-                if (held.result === undefined)
-                    facts.put(holder, HOLDER);
-                else
-                    owned = held.result === holder;
-            };
+    function prepareAgain(locator) {
+        const { unpreparable } = device.now();
+        device.set({
+            unpreparable: locator === undefined
+                ? new Set()
+                : new Set([...unpreparable].filter((held) => held !== locator)),
         });
-        return owned;
     }
-    finally {
-        authored.close();
+    function typed(locator, persisted) {
+        if (persisted.status === 'unavailable')
+            return persisted;
+        const schema = persisted.snapshot.schema;
+        const held = typesHeld.get(locator);
+        if (held !== undefined && held.schema === schema)
+            return { ...persisted, types: held.types };
+        const types = schemaTypes(schema, options.roomTypes);
+        typesHeld.set(locator, { schema, types });
+        return { ...persisted, types };
     }
-}
-export async function authoredBinding() {
-    const authored = await openAuthored();
-    try {
-        const held = await transacted(authored, FACTS, 'readonly', (transaction) => settled(transaction.objectStore(FACTS).get(BINDING)));
-        return typeof held === 'string' ? held : null;
+    function recordOf(stored) {
+        return { ...stored, model: typed(stored.locator, stored.model) };
     }
-    finally {
-        authored.close();
+    async function rooms(locators) {
+        const held = await (await open()).rooms(locators);
+        return new Map(held
+            .filter(({ record }) => !lost(record.locator))
+            .map(({ record, indexed, documents }) => [
+            record.locator,
+            { record: recordOf(record), indexed, documents },
+        ]));
     }
-}
-export async function bindAuthored(binding) {
-    const authored = await openAuthored();
-    try {
-        await transacted(authored, FACTS, 'readwrite', (transaction) => {
-            transaction.objectStore(FACTS).put(binding, BINDING);
-        });
+    async function work(locator) {
+        if (lost(locator))
+            return { replica: undefined, queue: [], states: new Map() };
+        const { room, queue } = await (await open()).room(locator);
+        const batches = queue.map(({ batch }) => batch);
+        const states = new Map(queue.map(({ batch, state }) => [batch.id, state]));
+        return {
+            replica: room === null
+                ? undefined
+                : { record: recordOf(room.record), queue: batches, states, overlaid: room.overlaid },
+            queue: batches,
+            states,
+        };
     }
-    finally {
-        authored.close();
+    async function drafts(locator, paths) {
+        const held = await (await open()).roomDrafts(locator, paths);
+        return held.filter((record) => !lost(record.locator));
     }
-}
-export async function removeRuntimeStore(holder) {
-    await removeDatabase(DATABASE);
-    if (holder !== undefined && (await authoredBy(holder)))
-        return true;
-    await removeDatabase(AUTHORED);
-    return false;
-}
-export function openDatabase(name, version, upgrade) {
-    return new Promise((resolve, reject) => {
-        const opening = indexedDB.open(name, version);
-        opening.onupgradeneeded = (event) => upgrade(opening, event.oldVersion);
-        opening.onsuccess = () => resolve(opening.result);
-        opening.onerror = () => {
-            if (opening.error?.name !== 'VersionError') {
-                reject(opening.error);
-                return;
-            }
-            removeDatabase(name)
-                .then(() => openDatabase(name, version, upgrade))
-                .then(resolve, reject);
-        };
-    });
-}
-function openReplica() {
-    return openDatabase(DATABASE, STORE_SCHEMA, (opening, oldVersion) => {
-        const database = opening.result;
-        if (oldVersion < REPLICA_SHAPE) {
-            for (const name of [...database.objectStoreNames])
-                database.deleteObjectStore(name);
-        }
-        for (const [name, parameters] of REPLICA_STORES) {
-            if (database.objectStoreNames.contains(name))
-                continue;
-            database.createObjectStore(name, parameters);
-        }
-        const messages = opening.transaction.objectStore(MESSAGES);
-        for (const [name, keyPath] of MESSAGE_INDEXES) {
-            if (!messages.indexNames.contains(name))
-                messages.createIndex(name, keyPath);
-        }
-    });
-}
-function openAuthored() {
-    return openDatabase(AUTHORED, AUTHORED_SCHEMA, (opening) => {
-        const database = opening.result;
-        for (const [name, parameters] of AUTHORED_STORES) {
-            if (!database.objectStoreNames.contains(name))
-                database.createObjectStore(name, parameters);
-        }
-    });
-}
-export async function openRuntimeStore(fenced) {
-    const authored = await openAuthored();
-    const database = await openReplica().catch((error) => {
-        authored.close();
-        throw error;
-    });
     return {
-        all() {
-            return transacted(database, [ROOMS, DOCUMENTS, BINARY_FILES], 'readonly', async (transaction) => {
-                const rooms = await settled(transaction.objectStore(ROOMS).getAll());
-                const records = [];
-                for (const room of rooms.filter((held) => !fenced(held.locator))) {
-                    records.push({
-                        ...room,
-                        ...(await readLayer(transaction, room.locator, room.transfer)),
-                    });
-                }
-                return records;
-            });
-        },
-        async keepAuthored({ locator, queue, founded, saved, roomDrafts, consumedRoomDrafts }) {
-            if (fenced(locator))
-                return;
-            await transacted(authored, [QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite', (transaction) => {
-                const order = transaction.objectStore(QUEUES);
-                const pending = transaction.objectStore(PENDING_CHANGES);
-                const held = order.get(locator);
-                held.onsuccess = () => {
-                    const before = new Set(held.result?.order ?? []);
-                    const after = new Set(queue.map((batch) => batch.id));
-                    if (queue.length === 0)
-                        order.delete(locator);
-                    else
-                        order.put({ locator, order: [...after] });
-                    for (const id of before) {
-                        if (!after.has(id))
-                            pending.delete([locator, id]);
-                    }
-                    for (const batch of queue) {
-                        if (!before.has(batch.id)) {
-                            pending.put({
-                                locator,
-                                id: batch.id,
-                                batch,
-                                drafts: saved?.get(batch.id) ?? [],
-                                submission: { state: 'waiting' },
-                                lost: false,
-                            });
-                        }
-                    }
-                    for (const batch of founded ?? []) {
-                        if (!before.has(batch.id))
-                            continue;
-                        const stored = pending.get([locator, batch.id]);
-                        stored.onsuccess = () => {
-                            const record = stored.result;
-                            if (record !== undefined)
-                                pending.put({ ...record, batch });
-                        };
-                    }
-                };
-                const draftStore = transaction.objectStore(ROOM_DRAFTS);
-                for (const path of consumedRoomDrafts ?? [])
-                    draftStore.delete([locator, path]);
-                for (const record of roomDrafts ?? [])
-                    draftStore.put(record);
-            });
-        },
-        async write({ next, previous, stored }) {
-            if (next === previous || fenced(next.locator))
-                return;
-            const moved = previous?.transfer !== next.transfer;
-            const base = moved ? (stored ?? null) : previous;
-            const paths = await stepped(changedIn(next, base));
-            if (fenced(next.locator))
-                return;
-            await transacted(database, [ROOMS, DOCUMENTS, BINARY_FILES, TRANSFERS], 'readwrite', (transaction) => {
-                transaction.objectStore(ROOMS).put(roomRecord(next));
-                if (moved && previous !== null) {
-                    const range = underTransfer(previous.locator, previous.transfer);
-                    transaction.objectStore(DOCUMENTS).delete(range);
-                    transaction.objectStore(BINARY_FILES).delete(range);
-                }
-                if (moved)
-                    transaction.objectStore(TRANSFERS).delete(next.locator);
-                return writeLayer(transaction, next.locator, next.transfer, { next, base, paths });
-            });
-        },
-        async revokeModels(records) {
-            await transacted(database, ROOMS, 'readwrite', (transaction) => {
-                const rooms = transaction.objectStore(ROOMS);
-                const revoked = { status: 'unavailable', reason: 'revoked' };
-                for (const record of records) {
-                    if (fenced(record.locator))
-                        continue;
-                    rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }));
-                }
-            });
-        },
-        async lastCompleted() {
-            return (await declaration(database)).lastCompleted;
-        },
-        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 member() {
-            const held = await transacted(database, DECLARATIONS, 'readonly', (transaction) => settled(transaction.objectStore(DECLARATIONS).get(MEMBER)));
-            return held ?? null;
-        },
-        async keepMember(member) {
-            await transacted(database, DECLARATIONS, 'readwrite', (transaction) => {
-                transaction.objectStore(DECLARATIONS).put(member, MEMBER);
-            });
-        },
-        async targets() {
-            const held = await transacted(database, DECLARATIONS, 'readonly', (transaction) => settled(transaction.objectStore(DECLARATIONS).get(TARGETS)));
-            return held ?? {};
-        },
-        async keepTargets(targets) {
-            await transacted(database, DECLARATIONS, 'readwrite', (transaction) => {
-                transaction.objectStore(DECLARATIONS).put(targets, TARGETS);
-            });
-        },
-        async queues() {
-            const [queues, pending] = await transacted(authored, [QUEUES, PENDING_CHANGES], 'readonly', (transaction) => Promise.all([
-                settled(transaction.objectStore(QUEUES).getAll()),
-                settled(transaction.objectStore(PENDING_CHANGES).getAll()),
-            ]));
-            const byId = new Map(pending.map((record) => [`${record.locator}\0${record.id}`, record]));
-            return queues
-                .filter((queue) => !fenced(queue.locator))
-                .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 keepUpload(locator, id, upload) {
-            if (!fenced(locator))
-                await amendPending(authored, locator, id, { upload });
-        },
-        async roomDrafts() {
-            const held = await transacted(authored, ROOM_DRAFTS, 'readonly', (transaction) => settled(transaction.objectStore(ROOM_DRAFTS).getAll()));
-            return held.filter((record) => !fenced(record.locator));
-        },
-        presentation() {
-            return transacted(database, PRESENTATION, 'readonly', (transaction) => settled(transaction.objectStore(PRESENTATION).getAll()));
-        },
-        async present(record) {
-            await transacted(database, PRESENTATION, 'readwrite', (transaction) => {
-                transaction.objectStore(PRESENTATION).put(record);
-            });
-        },
-        conversations() {
-            return transacted(database, [CONVERSATIONS, MESSAGES], 'readonly', async (transaction) => {
-                const records = await settled(transaction.objectStore(CONVERSATIONS).getAll());
-                const held = new Map(records.map(({ conversation, read, partial }) => [
-                    conversation,
-                    { conversation, read, partial: partial === true },
-                ]));
-                const keys = transaction.objectStore(MESSAGES).index('conversation');
-                await new Promise((resolve, reject) => {
-                    const cursor = keys.openKeyCursor(null, 'nextunique');
-                    cursor.onerror = () => reject(cursor.error);
-                    cursor.onsuccess = () => {
-                        const at = cursor.result;
-                        if (at === null) {
-                            resolve();
-                            return;
-                        }
-                        const conversation = at.key;
-                        if (!held.has(conversation)) {
-                            held.set(conversation, { conversation, read: undefined, partial: true });
-                        }
-                        at.continue();
-                    };
-                });
-                return [...held.values()];
-            });
-        },
-        async keepMessages({ conversation, messages, read }) {
-            await transacted(database, [CONVERSATIONS, MESSAGES], 'readwrite', (transaction) => {
-                const stored = transaction.objectStore(MESSAGES);
-                for (const message of messages) {
-                    stored.put({ ...message, conversation });
-                }
-                if (read !== undefined) {
-                    transaction.objectStore(CONVERSATIONS).put({
-                        conversation,
-                        read: read.at,
-                        ...(read.partial ? { partial: true } : {}),
-                    });
-                }
-            });
-        },
-        messageWindow(conversation, limit, before) {
-            return transacted(database, MESSAGES, 'readonly', async (transaction) => {
-                const index = transaction.objectStore(MESSAGES).index('position');
-                const range = IDBKeyRange.bound([conversation], [conversation, before?.[0] ?? []]);
-                const latest = [];
-                let more = false;
-                await new Promise((resolve, reject) => {
-                    const cursor = index.openCursor(range, 'prev');
-                    cursor.onerror = () => reject(cursor.error);
-                    cursor.onsuccess = () => {
-                        const at = cursor.result;
-                        if (at === null) {
-                            resolve();
-                            return;
-                        }
-                        const record = at.value;
-                        if (!precedes(record, before)) {
-                            at.continue();
-                            return;
-                        }
-                        if (latest.length === limit) {
-                            more = true;
-                            resolve();
-                            return;
-                        }
-                        latest.push(accepted(record));
-                        at.continue();
-                    };
-                });
-                return { messages: latest.reverse(), more };
-            });
-        },
-        messageCount(conversation) {
-            return transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).index('conversation').count(conversation)));
-        },
-        async messagesAfter(conversation, identity) {
-            const range = identity === null
-                ? IDBKeyRange.bound([conversation], [conversation, []])
-                : IDBKeyRange.bound([conversation, identity], [conversation, []], true);
-            const held = await transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).getAll(range, READ_BATCH)));
-            return held.map(accepted);
-        },
-        async messageIdentities(conversation) {
-            const keys = await transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).index('conversation').getAllKeys(conversation)));
-            return keys.map((key) => key[1]);
-        },
-        async turnArrived(conversation, turn) {
-            const held = await transacted(database, MESSAGES, 'readonly', (transaction) => settled(transaction.objectStore(MESSAGES).index('turn').count([conversation, turn])));
-            return held > 0;
-        },
-        async dropConversations(conversations) {
-            await transacted(authored, CHAT_DRAFTS, 'readwrite', (drafts) => {
-                for (const conversation of conversations)
-                    drafts.objectStore(CHAT_DRAFTS).delete(conversation);
-            });
-            await transacted(database, [CONVERSATIONS, MESSAGES], 'readwrite', (transaction) => {
-                const messages = transaction.objectStore(MESSAGES);
-                for (const conversation of conversations) {
-                    transaction.objectStore(CONVERSATIONS).delete(conversation);
-                    const keys = messages.index('conversation').getAllKeys(conversation);
-                    keys.onsuccess = () => {
-                        for (const key of keys.result)
-                            messages.delete(key);
-                    };
-                }
-            });
-        },
-        async chatDrafts() {
-            const held = await transacted(authored, CHAT_DRAFTS, 'readonly', (transaction) => settled(transaction.objectStore(CHAT_DRAFTS).getAll()));
-            return held.map(chatDraftRecord);
-        },
-        async keepChatDrafts(records) {
-            await transacted(authored, CHAT_DRAFTS, 'readwrite', (transaction) => {
-                for (const record of records)
-                    transaction.objectStore(CHAT_DRAFTS).put(record);
-            });
-        },
-        async dropChatDraft(conversation) {
-            await transacted(authored, CHAT_DRAFTS, 'readwrite', (transaction) => {
-                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
-            });
-        },
-        calls() {
-            return transacted(authored, CALLS, 'readonly', (transaction) => settled(transaction.objectStore(CALLS).getAll()));
-        },
-        async keepCall(record) {
-            await transacted(authored, CALLS, 'readwrite', (transaction) => {
-                transaction.objectStore(CALLS).put(record);
-            });
-        },
-        async dropCall(operation) {
-            await transacted(authored, CALLS, 'readwrite', (transaction) => {
-                transaction.objectStore(CALLS).delete(operation);
-            });
-        },
-        async keepRoomDraft(record) {
-            if (fenced(record.locator))
-                return;
-            await transacted(authored, ROOM_DRAFTS, 'readwrite', (transaction) => {
-                transaction.objectStore(ROOM_DRAFTS).put(record);
-            });
-        },
-        async discardRoomDraft(locator, path) {
-            if (fenced(locator))
-                return;
-            await transacted(authored, ROOM_DRAFTS, 'readwrite', (transaction) => {
-                transaction.objectStore(ROOM_DRAFTS).delete([locator, path]);
-            });
-        },
-        async fences() {
-            const held = await transacted(authored, FENCES, 'readonly', (transaction) => settled(transaction.objectStore(FENCES).getAll()));
-            return held.map((fence) => fence.locator);
-        },
-        async erase(locators) {
-            await transacted(authored, [FENCES, QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite', (work) => {
-                for (const locator of locators) {
-                    work.objectStore(FENCES).put({ locator });
-                    work.objectStore(QUEUES).delete(locator);
-                    for (const name of [PENDING_CHANGES, ROOM_DRAFTS]) {
-                        removeRoomEntries(work.objectStore(name), locator);
-                    }
-                }
-            });
-            await transacted(database, [ROOMS, DOCUMENTS, BINARY_FILES, TRANSFERS], 'readwrite', (transaction) => {
-                for (const locator of locators) {
-                    transaction.objectStore(ROOMS).delete(locator);
-                    transaction.objectStore(TRANSFERS).delete(locator);
-                    transaction.objectStore(DOCUMENTS).delete(underRoom(locator));
-                    transaction.objectStore(BINARY_FILES).delete(underRoom(locator));
-                }
-            });
-            await transacted(authored, FENCES, 'readwrite', (fences) => {
-                for (const locator of locators)
-                    fences.objectStore(FENCES).delete(locator);
-            });
-        },
-        async discard(locator) {
-            await transacted(authored, [QUEUES, PENDING_CHANGES], 'readwrite', (transaction) => {
-                transaction.objectStore(QUEUES).delete(locator);
-                removeRoomEntries(transaction.objectStore(PENDING_CHANGES), locator);
-            });
-        },
-        async transfers() {
-            const held = await transacted(database, TRANSFERS, 'readonly', (transaction) => settled(transaction.objectStore(TRANSFERS).getAll()));
-            return held.filter((record) => !fenced(record.locator));
-        },
-        staged(record) {
-            return transacted(database, [DOCUMENTS, BINARY_FILES], 'readonly', (transaction) => readLayer(transaction, record.locator, record.transfer));
-        },
-        async stage(record, page) {
-            if (fenced(record.locator))
-                return;
-            const paths = await stepped(changedIn(page, null));
-            if (fenced(record.locator))
-                return;
-            await transacted(database, [TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite', (transaction) => {
-                transaction.objectStore(TRANSFERS).put(record);
-                return writeLayer(transaction, record.locator, record.transfer, {
-                    next: page,
-                    base: null,
-                    paths,
-                });
-            });
-        },
-        async abandon(locator) {
-            if (fenced(locator))
-                return;
-            await transacted(database, [TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite', (transaction) => {
-                const transfers = transaction.objectStore(TRANSFERS);
-                const held = transfers.get(locator);
-                held.onsuccess = () => {
-                    const record = held.result;
-                    if (record === undefined)
-                        return;
-                    transfers.delete(locator);
-                    const range = underTransfer(locator, record.transfer);
-                    transaction.objectStore(DOCUMENTS).delete(range);
-                    transaction.objectStore(BINARY_FILES).delete(range);
-                };
-            });
-        },
-        receivedHeads() {
-            return transacted(database, RECEIVED, 'readonly', (transaction) => settled(transaction.objectStore(RECEIVED).getAll()));
-        },
-        async receivedParts(key, count) {
-            const kept = await transacted(database, RECEIVED_PARTS, 'readonly', (transaction) => settled(transaction
-                .objectStore(RECEIVED_PARTS)
-                .getAll(IDBKeyRange.bound([key, 0], [key, count], false, true))));
-            return kept.map((part) => part.value);
-        },
-        async keepReceived(key, head, part) {
-            await transacted(database, [RECEIVED, RECEIVED_PARTS], 'readwrite', (transaction) => {
-                transaction.objectStore(RECEIVED).put({ key, head });
-                if (part !== undefined)
-                    transaction.objectStore(RECEIVED_PARTS).put({ key, ...part });
-            });
-        },
-        async dropReceived(keys) {
-            await transacted(database, [RECEIVED, RECEIVED_PARTS], 'readwrite', (transaction) => {
-                for (const key of keys) {
-                    transaction.objectStore(RECEIVED).delete(key);
-                    transaction.objectStore(RECEIVED_PARTS).delete(IDBKeyRange.bound([key], [key, []]));
-                }
-            });
+        device,
+        space,
+        readiness,
+        ask: options.database.ask,
+        changed: options.changed,
+        open,
+        durably: (work) => writes.exclusive(async () => {
+            const local = await open();
+            return work(local);
+        }),
+        exclusive: writes.exclusive,
+        gathered: writes.gathered,
+        written: writes.written,
+        startingWrite: writes.startingWrite,
+        finishingWrite: writes.finishingWrite,
+        ahead: writes.ahead,
+        rederive: writes.rederive,
+        refreshPage: writes.refreshPage,
+        stageBytes: writes.stageBytes,
+        deriveBytes: writes.deriveBytes,
+        rooms,
+        record: async (locator) => (await rooms([locator])).get(locator)?.record,
+        work,
+        replica: async (locator) => (await work(locator)).replica,
+        async covering() {
+            const held = await (await open()).covering();
+            return {
+                rooms: new Map([...held.rooms].filter(([locator]) => !lost(locator))),
+                queues: new Map([...held.queues].filter(([locator]) => !lost(locator))),
+            };
         },
-        async generation() {
-            const held = await transacted(authored, FACTS, 'readonly', (transaction) => settled(transaction.objectStore(FACTS).get(GENERATION)));
-            return held ?? null;
+        async status() {
+            const held = await (await open()).status();
+            return {
+                queued: held.queued.filter((locator) => !lost(locator)),
+                lastCompleted: held.lastCompleted,
+                unsent: held.unsent.filter(({ room }) => !lost(room)),
+                resets: held.resets.filter(({ locator }) => !lost(locator)),
+                returned: held.returned.filter(({ locator }) => !lost(locator)),
+            };
         },
-        async rememberGeneration(value) {
-            await transacted(authored, FACTS, 'readwrite', (transaction) => {
-                transaction.objectStore(FACTS).put(value, GENERATION);
-            });
+        queued: async () => (await (await open()).queued()).filter((locator) => !lost(locator)),
+        drafts,
+        draft: async (locator, path) => (await drafts(locator, [path]))[0],
+        composed: ({ model, declaration }) => compositionOf(model, declaration.typedSelection, options.builtIn, options.typedPaths),
+        publication: watchers.publication,
+        owing: watchers.owing,
+        watch: watchers.watch,
+        watching: watchers.watching,
+        tell: watchers.tell,
+        installs,
+        seeds: {
+            of: (key) => seeds.get(key),
+            keep(key, seed) {
+                seeds.set(key, seed);
+            },
+            drop(key) {
+                seeds.delete(key);
+            },
+        },
+        landed,
+        attached,
+        opened: openedFiles(options.database, lost),
+        prepareAgain,
+        part: (file, part) => options.database.ask({ kind: 'file.part', key: file, part }),
+        forget(locator) {
+            typesHeld.delete(locator);
+            landed.forget(locator);
+            attached.forget(locator);
+            installs.change(locator, ({ installing }) => ({ ...NO_INSTALL, installing }));
+            prepareAgain(locator);
         },
         close() {
-            for (const held of [authored, database])
-                void idle(held).then(() => held.close());
+            space.stop();
+            readiness.close();
+            watchers.close();
         },
     };
 }