@agentshouse/mdruntime 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/connection.js

@@ -2,6 +2,7 @@ import { rawQuery } from './query.js';
 import { cached, modelTypes, NO_MODEL, sameModel } from './model.js';
 import { ROOM_CONTRACT_VERSION, VERSION_1_CAPABILITIES } from './adapter.js';
 import { bootstrapRoom } from './bootstrap.js';
+import { changeSet, mergeChangeSets } from './change-set.js';
 import { createConversationStore } from './conversation.js';
 import { MD_MODEL, PRESENTED, validRoot } from './collection.js';
 import { createLog } from './log.js';
@@ -78,6 +79,7 @@ export function createMdRuntime(options) {
     let refusal = null;
     let storageLoss = null;
     let status = STARTING;
+    let shown = STARTING;
     let discoveryPaused = false;
     let timer;
     let closed = false;
@@ -97,12 +99,14 @@ export function createMdRuntime(options) {
     const draftListeners = new Set();
     const presentationListeners = new Set();
     let withdrawConversations;
+    let currencyQueued = false;
     const conversations = createConversationStore({
         cards: declaredCards,
-        documents: ()=>visible({}),
+        documents: ()=>visible({}).documents,
         call: (name, input)=>invokeAction(name, input),
         durably,
-        path: ()=>options.adapter.conversations,
+        stream: ()=>options.adapter.conversations,
+        publish: publishChangeSet,
         closed: ()=>closed
     });
     const journal = createLog();
@@ -142,10 +146,6 @@ export function createMdRuntime(options) {
         });
         return entries;
     }
-    async function readDrafts(opened) {
-        await hydrate(opened);
-        return snapshotDrafts();
-    }
     function publishDrafts(waitingOnly) {
         if (closed) return;
         const value = snapshotDrafts();
@@ -171,13 +171,15 @@ export function createMdRuntime(options) {
             if (listener.app === app && listener.ready) listener.notify(presentationOf(app));
         }
     }
-    function commitDraft(work) {
+    function commitDraft(locator, path, work) {
         return exclusive(async ()=>{
             const local = await openLocal();
-            await hydrate(local);
             await work(local);
-        }).then(()=>{
-            emitDrafts();
+            publishChangeSet(changeSet(locator, null, null, {
+                drafts: [
+                    path
+                ]
+            }));
         });
     }
     function pending() {
@@ -214,19 +216,13 @@ export function createMdRuntime(options) {
             reset
         };
     }
-    function storedOutcomes(batches) {
-        const stored = {};
-        for (const batch of batches){
-            const outcome = queuedOutcome(outcomes.get(batch.id));
-            if (outcome.kind !== 'pending') stored[batch.id] = outcome;
-        }
-        return stored;
-    }
-    async function persistQueue(local, locator, batches) {
-        await local.writeQueue({
-            locator,
-            batches,
-            outcomes: storedOutcomes(batches)
+    async function persistQueue(local, replica, batches, changedOutcomes = []) {
+        await local.write({
+            next: replica.confirmed.record,
+            previous: replica.confirmed.record,
+            queue: batches,
+            previousQueue: replica.queue,
+            outcomes: changedOutcomes
         });
     }
     function listed() {
@@ -270,9 +266,19 @@ export function createMdRuntime(options) {
         for (const listener of storageLossListeners)listener(storageLoss);
     }
     function moveTo(next) {
-        if (closed || same(status, next)) return;
+        if (closed) return;
         status = next;
-        for (const listener of statusListeners)listener(status);
+        show();
+    }
+    function show() {
+        if (closed) return;
+        const next = status.state === 'synced' && !conversations.current() ? {
+            ...status,
+            state: 'syncing'
+        } : status;
+        if (same(shown, next)) return;
+        shown = next;
+        for (const listener of statusListeners)listener(shown);
     }
     function visible(request) {
         if (options.queryBinding === null) {
@@ -308,6 +314,18 @@ export function createMdRuntime(options) {
             if (subscription.locator === locator) subscription.notify(entries);
         }
     }
+    function publishChangeSet(set) {
+        if (set.rooms.length > 0) emitRooms();
+        if (set.documents.length > 0 || set.query) emitVisible();
+        for (const locator of set.queues)emitQueue(locator);
+        if (set.drafts.length > 0) emitDrafts();
+        for (const app of set.presentations)emitPresentation(app);
+        conversations.changed(set);
+        const cards = declaredCards();
+        if (cards !== undefined && set.documents.some((change)=>change.locator === cards.locator)) {
+            scheduleCurrency();
+        }
+    }
     function stopTimer() {
         if (timer === undefined) return;
         clearInterval(timer);
@@ -319,55 +337,76 @@ export function createMdRuntime(options) {
             void enqueue();
         }, period);
     }
-    function refuse(reason, provider = null) {
-        if (reason === 'revoked-authorization') {
-            const revoked = {
-                status: 'unavailable',
-                reason: 'revoked'
-            };
-            const attachments = [
-                'collection',
-                'typed-selection'
-            ];
-            const keys = new Set(models.keys());
-            for (const locator of rooms.keys()){
-                for (const attached of attachments)keys.add(modelKey(locator, attached));
-            }
-            for (const key of keys){
-                invalidModels.add(key);
-                modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
-                models.set(key, revoked);
-                liveModels.delete(key);
-            }
-            for (const [locator, room] of rooms)rooms.set(locator, {
-                ...room,
-                model: modelTypes(revoked),
-                typedSelection: room.typedSelection === null ? null : {
-                    ...room.typedSelection,
-                    model: modelTypes(revoked)
-                }
-            });
-            emitRooms();
-            void exclusive(async ()=>{
-                const local = await openLocal();
-                for (const record of (await local.all()))await local.publish({
-                    ...record,
-                    model: revoked,
-                    selectionModel: revoked
-                });
-            }).catch(()=>{
-                journal.record('model invalidation durable-write failure');
-            });
-        }
+    async function refuse(reason, provider = null) {
         stopTimer();
         discoveryPaused = true;
-        refusal = {
-            reason,
-            reauthorizationOffered: reason === 'revoked-authorization',
-            refusal: provider
-        };
-        journal.record(`connection refused ${reason}`);
-        emitRefusal();
+        try {
+            if (reason === 'revoked-authorization') {
+                await exclusive(async ()=>{
+                    const revoked = {
+                        status: 'unavailable',
+                        reason: 'revoked'
+                    };
+                    try {
+                        const local = await openLocal();
+                        await local.revokeModels([
+                            ...replicas.values()
+                        ].map((replica)=>({
+                                record: replica.confirmed.record,
+                                queue: replica.queue
+                            })));
+                    } catch  {
+                        journal.record('model revocation persistence failed');
+                    }
+                    const keys = new Set(models.keys());
+                    for (const locator of rooms.keys()){
+                        keys.add(modelKey(locator, 'collection'));
+                        keys.add(modelKey(locator, 'typed-selection'));
+                    }
+                    for (const key of keys){
+                        invalidModels.add(key);
+                        modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
+                        models.set(key, revoked);
+                        liveModels.delete(key);
+                    }
+                    const changed = [];
+                    for (const [locator, room] of rooms){
+                        const before = replicas.get(locator) ?? null;
+                        if (before !== null) {
+                            const record = {
+                                ...before.confirmed.record,
+                                model: revoked,
+                                selectionModel: revoked
+                            };
+                            const confirmed = readConfirmed(record, before.confirmed);
+                            if (confirmed === null) throw new Error(`Cannot retype revoked Room ${locator}`);
+                            replicas.set(locator, replicaOf(confirmed, before.queue, rewriting(), before));
+                        }
+                        rooms.set(locator, {
+                            ...room,
+                            model: modelTypes(revoked),
+                            typedSelection: room.typedSelection === null ? null : {
+                                ...room.typedSelection,
+                                model: modelTypes(revoked)
+                            }
+                        });
+                        changed.push(changeSet(locator, before, replicas.get(locator) ?? null, {
+                            room: true,
+                            query: true
+                        }));
+                    }
+                    publishChangeSet(mergeChangeSets(changed));
+                });
+            }
+        } finally{
+            refusal = {
+                reason,
+                reauthorizationOffered: reason === 'revoked-authorization',
+                refusal: provider
+            };
+            journal.record(`connection refused ${reason}`);
+            emitRefusal();
+        }
     }
     function list(room, synchronizationAvailable) {
         const selection = room.typedSelection ?? null;
@@ -417,7 +456,6 @@ export function createMdRuntime(options) {
     async function dropUnlisted(listed, local) {
         if (unlistedHeld(listed).length === 0) return;
         await exclusive(async ()=>{
-            await hydrate(local);
             const unlisted = unlistedHeld(listed);
             await local.dropRooms(unlisted);
             for (const [batch, locator] of acceptedIn){
@@ -425,6 +463,14 @@ export function createMdRuntime(options) {
                 acceptedIn.delete(batch);
                 outcomes.delete(batch);
             }
+            const removed = unlisted.map((locator)=>changeSet(locator, replicas.get(locator) ?? null, null, {
+                    room: true,
+                    queue: true,
+                    query: true,
+                    drafts: [
+                        ...drafts.get(locator)?.keys() ?? []
+                    ]
+                }));
             for (const locator of unlisted){
                 for (const batch of replicas.get(locator)?.queue ?? [])outcomes.delete(batch.id);
                 replicas.delete(locator);
@@ -444,9 +490,7 @@ export function createMdRuntime(options) {
                 }
                 journal.record(`room unlisted ${locator}`);
             }
-            emitVisible();
-            for (const locator of unlisted)emitQueue(locator);
-            emitDrafts();
+            publishChangeSet(mergeChangeSets(removed));
             moveTo({
                 ...status,
                 ...attention()
@@ -468,13 +512,14 @@ export function createMdRuntime(options) {
         return model;
     }
     async function hydrate(opened) {
-        const [records, queues, kept, presented, cached, unsent, lastCompleted, declared, named, listedSlots] = await Promise.all([
+        const [records, queues, recordedOutcomes, kept, presented, held, chatDrafts, lastCompleted, declared, named, listedSlots] = await Promise.all([
             opened.all(),
             opened.queues(),
+            opened.outcomes(),
             opened.drafts(),
             opened.presentation(),
             opened.conversations(),
-            opened.instructions(),
+            opened.chatDrafts(),
             opened.lastCompleted(),
             opened.providerLimits(),
             opened.capabilities(),
@@ -487,27 +532,30 @@ export function createMdRuntime(options) {
         for (const draft of kept)rememberDraft(draft.locator, draft.path, draft.content);
         presentations.clear();
         for (const record of presented)presentations.set(record.app, record.value);
-        conversations.hydrate(cached, unsent);
+        conversations.hydrate(held, chatDrafts);
         const queuedBatches = new Map(queues.map((queue)=>[
                 queue.locator,
                 queue.batches
             ]));
-        for (const queue of queues){
-            for (const [id, outcome] of Object.entries(queue.outcomes)){
-                outcomes.set(id, outcome);
-            }
+        outcomes.clear();
+        acceptedIn.clear();
+        for (const record of recordedOutcomes){
+            outcomes.set(record.id, record.outcome);
+            if (record.outcome.kind === 'accepted') acceptedIn.set(record.id, record.locator);
         }
+        const previousReplicas = new Map(replicas);
         replicas.clear();
         for (const record of records){
             const model = restored(modelKey(record.locator, 'collection'), record.model);
             const selectionModel = restored(modelKey(record.locator, 'typed-selection'), record.selectionModel);
+            const prior = previousReplicas.get(record.locator);
             const confirmed = readConfirmed({
                 ...record,
                 model,
                 selectionModel
-            });
+            }, prior?.confirmed);
             if (confirmed === null) continue;
-            replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? [], rewriting()));
+            replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? [], rewriting(), prior));
             const existing = rooms.get(record.locator);
             if (existing === undefined) list(record, false);
             else {
@@ -568,7 +616,6 @@ export function createMdRuntime(options) {
     function durably(work) {
         return exclusive(async ()=>{
             const local = await openLocal();
-            await hydrate(local);
             return work(local);
         });
     }
@@ -586,25 +633,30 @@ export function createMdRuntime(options) {
     }
     function publish(local, room, confirmed) {
         return exclusive(async ()=>{
-            await hydrate(local);
+            const prior = replicas.get(room.locator);
             const retained = readConfirmed({
                 ...confirmed.record,
                 model: modelOf(room.locator),
                 selectionModel: modelOf(room.locator, 'typed-selection')
-            });
+            }, prior?.confirmed);
             if (retained !== null) {
-                await local.publish(retained.record);
+                await local.write({
+                    next: retained.record,
+                    previous: prior?.confirmed.record ?? null,
+                    queue: prior?.queue ?? []
+                });
                 unreadable.delete(room.locator);
-                replicas.set(room.locator, replicaOf(retained, replicas.get(room.locator)?.queue ?? [], rewriting()));
+                replicas.set(room.locator, replicaOf(retained, prior?.queue ?? [], rewriting(), prior));
             }
             list(room, true);
-            emitRooms();
-            emitVisible();
+            publishChangeSet(changeSet(room.locator, prior ?? null, replicas.get(room.locator) ?? null, {
+                room: true,
+                query: true
+            }));
         });
     }
     async function write(locator, changes, replacing, writtenBy) {
         const local = await openLocal();
-        await hydrate(local);
         const replica = replicas.get(locator);
         const room = rooms.get(locator);
         if (replica === undefined || room === undefined) {
@@ -650,11 +702,19 @@ export function createMdRuntime(options) {
             ...new Set(changes.map((change)=>change.path))
         ];
         try {
-            await local.append({
-                locator,
-                batches,
-                outcomes: storedOutcomes(batches)
-            }, consumed);
+            await local.write({
+                next: replica.confirmed.record,
+                previous: replica.confirmed.record,
+                queue: batches,
+                previousQueue: replica.queue,
+                outcomes: replacing === undefined ? [] : [
+                    {
+                        id: replacing,
+                        outcome: null
+                    }
+                ],
+                consumedDrafts: consumed
+            });
         } catch  {
             return {
                 outcome: 'refused',
@@ -663,10 +723,11 @@ export function createMdRuntime(options) {
         }
         if (replacing !== undefined) outcomes.delete(replacing);
         for (const path of consumed)forgetDraft(locator, path);
-        replicas.set(locator, replicaOf(replica.confirmed, batches, rewriting()));
-        emitQueue(locator);
-        emitVisible();
-        emitDrafts();
+        replicas.set(locator, replicaOf(replica.confirmed, batches, rewriting(), replica));
+        publishChangeSet(changeSet(locator, replica, replicas.get(locator) ?? null, {
+            queue: true,
+            drafts: consumed
+        }));
         moveTo({
             ...saving(status),
             ...attention()
@@ -679,18 +740,23 @@ export function createMdRuntime(options) {
     }
     async function discardHead(locator, identifier) {
         const local = await openLocal();
-        await hydrate(local);
         const replica = replicas.get(locator);
         const head = replica?.queue[0];
         if (replica === undefined || head === undefined || head.id !== identifier || !refused(outcomes.get(head.id))) {
             return;
         }
         const batches = replica.queue.slice(1);
+        await persistQueue(local, replica, batches, [
+            {
+                id: identifier,
+                outcome: null
+            }
+        ]);
         outcomes.delete(identifier);
-        await persistQueue(local, locator, batches);
-        replicas.set(locator, replicaOf(replica.confirmed, batches, rewriting()));
-        emitQueue(locator);
-        emitVisible();
+        replicas.set(locator, replicaOf(replica.confirmed, batches, rewriting(), replica));
+        publishChangeSet(changeSet(locator, replica, replicas.get(locator) ?? null, {
+            queue: true
+        }));
         moveTo({
             ...status,
             state: pending() ? 'pending' : status.state,
@@ -739,7 +805,7 @@ export function createMdRuntime(options) {
                 const room = replicas.get(result.locator)?.confirmed.record;
                 if (room !== undefined) await scoped(result, room, await openLocal());
             }
-            if (result.kind === 'revoked-authorization') refuse('revoked-authorization');
+            if (result.kind === 'revoked-authorization') await refuse('revoked-authorization');
             return result;
         } catch  {
             journal.record('outcome history transport-uncertainty');
@@ -792,7 +858,7 @@ export function createMdRuntime(options) {
                 const room = replicas.get(result.locator)?.confirmed.record;
                 if (room !== undefined) await scoped(result, room, await openLocal());
             }
-            if (result.kind === 'revoked-authorization') refuse('revoked-authorization');
+            if (result.kind === 'revoked-authorization') await refuse('revoked-authorization');
             journal.record(`outcome action ${result.kind}`);
             if (result.kind === 'rejected') journal.record(`refusal rejected ${result.code}`);
             return result;
@@ -885,7 +951,6 @@ export function createMdRuntime(options) {
         };
     }
     async function commitAccept(room, local, submitted, accepted, base, overlay) {
-        await hydrate(local);
         const current = replicas.get(room.locator);
         if (current === undefined || !current.queue.some((batch)=>batch.id === submitted.id)) {
             return true;
@@ -895,14 +960,11 @@ export function createMdRuntime(options) {
             ...base.record,
             model: modelOf(room.locator),
             selectionModel: modelOf(room.locator, 'typed-selection')
-        });
+        }, base);
         if (retainedBase === null) return false;
         const applied = overlay ? applyReturned(retainedBase, accepted.documents, accepted.revisions, accepted.removals, accepted.roomVersion, options.modelBinding) : retainedBase;
         if (applied === null) return false;
-        await local.publish(applied.record);
-        await persistQueue(local, room.locator, remaining);
-        acceptedIn.set(submitted.id, room.locator);
-        outcomes.set(submitted.id, {
+        const acceptedOutcome = {
             kind: 'accepted',
             roomVersion: accepted.roomVersion,
             ...accepted.author === undefined ? {} : {
@@ -911,13 +973,29 @@ export function createMdRuntime(options) {
             ...accepted.time === undefined ? {} : {
                 time: accepted.time
             }
+        };
+        await local.write({
+            next: applied.record,
+            previous: current.confirmed.record,
+            queue: remaining,
+            previousQueue: current.queue,
+            outcomes: [
+                {
+                    id: submitted.id,
+                    outcome: acceptedOutcome
+                }
+            ]
         });
+        acceptedIn.set(submitted.id, room.locator);
+        outcomes.set(submitted.id, acceptedOutcome);
         unreadable.delete(room.locator);
-        replicas.set(room.locator, replicaOf(applied, remaining, rewriting()));
+        replicas.set(room.locator, replicaOf(applied, remaining, rewriting(), current));
         list(room, true);
-        emitRooms();
-        emitQueue(room.locator);
-        emitVisible();
+        publishChangeSet(changeSet(room.locator, current, replicas.get(room.locator) ?? null, {
+            room: true,
+            queue: true,
+            query: true
+        }));
         journal.record(`outcome ${room.locator} ${submitted.id} accepted ${accepted.roomVersion}` + (accepted.author === undefined ? '' : ` author ${accepted.author}`) + (accepted.time === undefined ? '' : ` time ${accepted.time}`));
         return true;
     }
@@ -934,12 +1012,18 @@ export function createMdRuntime(options) {
                     return null;
                 }
                 await exclusive(async ()=>{
-                    await hydrate(local);
                     const current = replicas.get(room.locator);
                     if (current === undefined || current.queue[0]?.id !== head.id) return;
+                    await persistQueue(local, current, current.queue, [
+                        {
+                            id: head.id,
+                            outcome: null
+                        }
+                    ]);
                     outcomes.delete(head.id);
-                    await persistQueue(local, room.locator, current.queue);
-                    emitQueue(room.locator);
+                    publishChangeSet(changeSet(room.locator, current, current, {
+                        queue: true
+                    }));
                     moveTo({
                         ...status,
                         ...attention()
@@ -948,6 +1032,11 @@ export function createMdRuntime(options) {
             }
             let result;
             journal.record(`submission ${room.locator} ${head.id}`);
+            if (await local.markSubmitted(room.locator, head.id)) {
+                publishChangeSet(changeSet(room.locator, replica, replica, {
+                    queue: true
+                }));
+            }
             try {
                 result = await options.adapter.mutate(authorized, {
                     locator: room.locator,
@@ -972,7 +1061,7 @@ export function createMdRuntime(options) {
                 return null;
             }
             if (result.kind === 'revoked-authorization') {
-                refuse('revoked-authorization');
+                await refuse('revoked-authorization');
                 return 'stop';
             }
             if (result.kind === 'scoped-refusal') {
@@ -985,14 +1074,21 @@ export function createMdRuntime(options) {
                 if (result.kind !== 'expired') journal.record(`refusal ${result.kind} ${result.code}`);
                 if (result.kind === 'retryable-refusal') progress.complete = false;
                 await exclusive(async ()=>{
-                    await hydrate(local);
                     const current = replicas.get(room.locator);
                     if (current === undefined || !current.queue.some((batch)=>batch.id === head.id)) {
                         return;
                     }
-                    outcomes.set(head.id, recordRefusal(result));
-                    await persistQueue(local, room.locator, current.queue);
-                    emitQueue(room.locator);
+                    const recorded = recordRefusal(result);
+                    await persistQueue(local, current, current.queue, [
+                        {
+                            id: head.id,
+                            outcome: recorded
+                        }
+                    ]);
+                    outcomes.set(head.id, recorded);
+                    publishChangeSet(changeSet(room.locator, current, current, {
+                        queue: true
+                    }));
                     moveTo({
                         ...status,
                         ...attention()
@@ -1004,7 +1100,7 @@ export function createMdRuntime(options) {
             if (from === undefined) return null;
             const pulled = await pullRefresh(authorized, from);
             if (pulled.kind === 'revoked-authorization') {
-                refuse('revoked-authorization');
+                await refuse('revoked-authorization');
                 return 'stop';
             }
             if (pulled.kind === 'scoped-refusal') {
@@ -1032,7 +1128,7 @@ export function createMdRuntime(options) {
             if (pulled.kind === 'beyond-horizon') {
                 const bootstrapped = await pullBootstrap(authorized, room);
                 if (bootstrapped.kind === 'revoked-authorization') {
-                    refuse('revoked-authorization');
+                    await refuse('revoked-authorization');
                     return 'stop';
                 }
                 if (bootstrapped.kind === 'scoped-refusal') {
@@ -1084,7 +1180,6 @@ export function createMdRuntime(options) {
             liveModels.delete(key);
         }
         await exclusive(async ()=>{
-            await hydrate(local);
             if (next.status !== 'unavailable' && epoch !== (modelEpoch.get(key) ?? 0)) return;
             const held = replicas.get(room.locator);
             if (held !== undefined) {
@@ -1100,9 +1195,15 @@ export function createMdRuntime(options) {
                         selectionModel: next
                     }
                 };
-                await local.publish(record);
-                const confirmed = readConfirmed(record);
-                if (confirmed !== null) replicas.set(room.locator, replicaOf(confirmed, held.queue, rewriting()));
+                await local.write({
+                    next: record,
+                    previous: held.confirmed.record,
+                    queue: held.queue
+                });
+                const confirmed = readConfirmed(record, held.confirmed);
+                if (confirmed !== null) {
+                    replicas.set(room.locator, replicaOf(confirmed, held.queue, rewriting(), held));
+                }
             }
             models.set(key, next);
             if (next.status === 'current') {
@@ -1110,8 +1211,11 @@ export function createMdRuntime(options) {
                 invalidModels.delete(key);
             }
             list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
-            emitRooms();
-            if (queryChanged && held !== undefined) emitVisible();
+            if (held === undefined) emitRooms();
+            else publishChangeSet(changeSet(room.locator, held, replicas.get(room.locator) ?? null, {
+                room: true,
+                query: queryChanged
+            }));
         });
     }
     async function acquireModel(local, room, authorized, selection) {
@@ -1147,11 +1251,7 @@ export function createMdRuntime(options) {
         }
         if (epoch !== (modelEpoch.get(key) ?? 0)) return;
         if (answer.kind === 'revoked-authorization') {
-            await retainModel(local, room, attached, {
-                status: 'unavailable',
-                reason: 'revoked'
-            });
-            refuse('revoked-authorization');
+            await refuse('revoked-authorization');
             return;
         }
         if (answer.kind === 'transport-uncertainty') {
@@ -1271,7 +1371,7 @@ export function createMdRuntime(options) {
                     continue;
                 }
                 if (withheld.kind === 'revoked-authorization') {
-                    refuse('revoked-authorization');
+                    await refuse('revoked-authorization');
                     return;
                 }
                 continue;
@@ -1311,7 +1411,7 @@ export function createMdRuntime(options) {
         }
         if (result.kind === 'contract-unavailable') {
             journal.record(`connection contract unavailable ${result.code}`);
-            refuse('missing-required-guarantee', {
+            await refuse('missing-required-guarantee', {
                 code: result.code,
                 fields: result.fields
             });
@@ -1319,17 +1419,17 @@ export function createMdRuntime(options) {
             return;
         }
         if (result.kind === 'revoked-authorization') {
-            refuse('revoked-authorization');
+            await refuse('revoked-authorization');
             notifyReady();
             return;
         }
         if (!result.supportedVersions.includes(ROOM_CONTRACT_VERSION)) {
-            refuse('no-matching-version');
+            await refuse('no-matching-version');
             notifyReady();
             return;
         }
         if (result.mdModel.identity !== MD_MODEL.identity || result.mdModel.version !== MD_MODEL.version) {
-            refuse('md-model-version-mismatch');
+            await refuse('md-model-version-mismatch');
             notifyReady();
             return;
         }
@@ -1347,13 +1447,13 @@ export function createMdRuntime(options) {
                 'unavailable'
             ].includes(room.replica.admission) || !declaredIdentity(room.attachedModel)) {
                 journal.record(`invalid model or replica declaration ${room.locator}`);
-                refuse('missing-required-guarantee');
+                await refuse('missing-required-guarantee');
                 notifyReady();
                 return;
             }
             if (!declaredSelection(room)) {
                 journal.record(`invalid typed selection declaration ${room.locator}`);
-                refuse('missing-required-guarantee');
+                await refuse('missing-required-guarantee');
                 notifyReady();
                 return;
             }
@@ -1363,14 +1463,14 @@ export function createMdRuntime(options) {
             }
         }
         if (mismatchedRoots.size > 0) {
-            refuse('missing-required-guarantee');
+            await refuse('missing-required-guarantee');
             notifyReady();
             return;
         }
         const declared = new Set(result.capabilities.map((capability)=>capability.name));
         for (const required of options.requiredGuarantees){
             if (!knownCapabilities.has(required) || !declared.has(required)) {
-                refuse('missing-required-guarantee');
+                await refuse('missing-required-guarantee');
                 notifyReady();
                 return;
             }
@@ -1394,6 +1494,10 @@ export function createMdRuntime(options) {
         handSelected(result.rooms.filter((room)=>room.replica.admission === 'admitted').map((room)=>room.locator).sort());
         progress.complete = true;
         await synchronize(result.rooms, local, progress);
+        if (closed || discoveryPaused) return;
+        await conversations.reconcile();
+        if (status.providerUnreachable) conversations.reconnected();
+        await conversations.catchUp(progress);
     }
     async function ensureAuthorization() {
         if (authorization !== undefined) return;
@@ -1457,12 +1561,44 @@ export function createMdRuntime(options) {
         });
     }
     function observeConversations() {
-        const path = options.adapter.conversations;
-        if (path === undefined || withdrawConversations !== undefined) return;
-        withdrawConversations = path.observe((event)=>{
+        const stream = options.adapter.conversations;
+        if (stream === undefined || withdrawConversations !== undefined) return;
+        withdrawConversations = stream.observe((event)=>{
             conversations.receive(event);
+            if (event.kind !== 'gap' || conversations.current()) return;
+            show();
+            scheduleCurrency();
         });
     }
+    function scheduleCurrency() {
+        if (currencyQueued || closed) return;
+        currencyQueued = true;
+        chain = chain.then(runCurrency, runCurrency);
+    }
+    async function runCurrency() {
+        currencyQueued = false;
+        if (closed || discoveryPaused) return;
+        await conversations.reconcile();
+        if (conversations.current()) {
+            show();
+            return;
+        }
+        const resting = status;
+        const progress = {
+            complete: false,
+            reachable: !resting.providerUnreachable
+        };
+        moveTo(transferring(resting));
+        try {
+            await conversations.catchUp(progress);
+        } catch  {
+            progress.reachable = false;
+        } finally{
+            if (!closed) {
+                moveTo(settled(resting, progress, resting.lastCompleted, pending(), attention()));
+            }
+        }
+    }
     function handSelected(locators) {
         const path = options.adapter.roomVersions;
         if (path === undefined || withdrawNotifications === undefined) return;
@@ -1508,7 +1644,7 @@ export function createMdRuntime(options) {
                     continue;
                 }
                 if (withheld.kind === 'revoked-authorization') {
-                    refuse('revoked-authorization');
+                    await refuse('revoked-authorization');
                     return;
                 }
             }
@@ -1559,6 +1695,9 @@ export function createMdRuntime(options) {
     });
     void enqueue();
     return {
+        loaded () {
+            return openLocal().then(()=>undefined);
+        },
         rooms () {
             return listed();
         },
@@ -1575,13 +1714,13 @@ export function createMdRuntime(options) {
             };
         },
         syncStatus () {
-            return status;
+            return shown;
         },
         draft: {
             list () {
                 return exclusive(async ()=>{
-                    const local = await openLocal();
-                    return readDrafts(local);
+                    await openLocal();
+                    return snapshotDrafts();
                 }).then((entries)=>{
                     releaseWaitingDrafts();
                     return entries;
@@ -1592,7 +1731,7 @@ export function createMdRuntime(options) {
                 return content === undefined ? null : structuredClone(content);
             },
             replace (locator, path, content) {
-                return commitDraft(async (local)=>{
+                return commitDraft(locator, path, async (local)=>{
                     const stored = structuredClone(content);
                     await local.keep({
                         locator,
@@ -1603,32 +1742,33 @@ export function createMdRuntime(options) {
                 });
             },
             discard (locator, path) {
-                return commitDraft(async (local)=>{
+                return commitDraft(locator, path, async (local)=>{
                     await local.discard(locator, path);
                     forgetDraft(locator, path);
                 });
             }
         },
         conversation: conversations.surface,
+        chatDraft: conversations.chatDraft,
         presentation: {
             read (app) {
                 return exclusive(async ()=>{
-                    await hydrate(await openLocal());
+                    await openLocal();
                     return presentationOf(app);
                 });
             },
             write (app, value) {
                 return exclusive(async ()=>{
                     const local = await openLocal();
-                    await hydrate(local);
                     const stored = structuredClone(value);
                     await local.present({
                         app,
                         value: stored
                     });
                     presentations.set(app, stored);
-                }).then(()=>{
-                    emitPresentation(app);
+                    publishChangeSet(changeSet('', null, null, {
+                        presentation: app
+                    }));
                 });
             }
         },
@@ -1665,7 +1805,7 @@ export function createMdRuntime(options) {
         persistence () {
             return options.shell.persistentStorage;
         },
-        observe (topic, second, third) {
+        observe (topic, second, third, fourth) {
             if (topic === 'drafts') {
                 const notify = second;
                 const listener = {
@@ -1674,8 +1814,7 @@ export function createMdRuntime(options) {
                 };
                 draftListeners.add(listener);
                 void exclusive(async ()=>{
-                    const local = await openLocal();
-                    await readDrafts(local);
+                    await openLocal();
                     if (closed || !draftListeners.has(listener)) return;
                     listener.ready = true;
                 }).then(()=>{
@@ -1687,7 +1826,7 @@ export function createMdRuntime(options) {
                 };
             }
             if (topic === 'conversation') {
-                return conversations.observe(second, third);
+                return conversations.observe(second, third, fourth);
             }
             if (topic === 'presentation') {
                 const listener = {
@@ -1697,7 +1836,7 @@ export function createMdRuntime(options) {
                 };
                 presentationListeners.add(listener);
                 void exclusive(async ()=>{
-                    await hydrate(await openLocal());
+                    await openLocal();
                 }).then(()=>{
                     if (closed || !presentationListeners.has(listener)) return;
                     listener.ready = true;
@@ -1734,7 +1873,7 @@ export function createMdRuntime(options) {
             if (topic === 'sync-status') {
                 const notify = second;
                 statusListeners.add(notify);
-                notify(status);
+                notify(shown);
                 return ()=>{
                     statusListeners.delete(notify);
                 };
@@ -1764,6 +1903,7 @@ export function createMdRuntime(options) {
         async reauthorize () {
             if (refusal === null || !refusal.reauthorizationOffered) return;
             journal.record('connection reauthorize');
+            await mutations;
             authorization = undefined;
             discoveryPaused = false;
             await enqueue();