@agentshouse/mdruntime 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/connection.js

@@ -2,10 +2,13 @@ import { query as evaluate } from '@agentshouse/query';
 import { ROOM_CONTRACT_VERSION, VERSION_1_CAPABILITIES } from './adapter.js';
 import { bootstrapRoom } from './bootstrap.js';
 import { MD_MODEL, PRESENTED } from './collection.js';
+import { createLog } from './log.js';
+import { queuedOutcome, refused } from './outcome.js';
 import { refreshRoom } from './refresh.js';
 import { buildBatch } from './save.js';
-import { readConfirmed, replicaOf } from './replica.js';
+import { applyReturned, readConfirmed, replicaOf } from './replica.js';
 import { settled, same, saving, STARTING, transferring } from './status.js';
+import { detectStorageLoss, nextGeneration } from './durability.js';
 import { openReplicaStore } from './store.js';
 import { unconfirmed } from './transfer.js';
 const DEFAULT_DISCOVERY_INTERVAL_MS = 60_000;
@@ -17,10 +20,13 @@ export function createMdRuntime(options) {
     let store;
     const replicas = new Map();
     const drafts = new Map();
+    const outcomes = new Map();
     let limits = [];
+    let capabilities = [];
     const rooms = new Map();
     const unreadable = new Set();
     let refusal = null;
+    let storageLoss = null;
     let status = STARTING;
     let discoveryPaused = false;
     let timer;
@@ -31,9 +37,19 @@ export function createMdRuntime(options) {
     let queued = false;
     const roomListeners = new Set();
     const refusalListeners = new Set();
+    const storageLossListeners = new Set();
     const statusListeners = new Set();
     const querySubscriptions = new Set();
     const queueSubscriptions = new Set();
+    const journal = createLog();
+    let notifyReady = ()=>{};
+    const ready = new Promise((resolve)=>{
+        notifyReady = resolve;
+    });
+    let leader = typeof window === 'undefined';
+    let applyingRemote = false;
+    let releaseLeadership = ()=>{};
+    const channel = typeof window !== 'undefined' ? new BroadcastChannel('mdruntime') : undefined;
     function at(locator, path) {
         return `${locator} ${path}`;
     }
@@ -42,6 +58,30 @@ export function createMdRuntime(options) {
             ...replicas.values()
         ].some((replica)=>replica.queue.length > 0);
     }
+    function attention() {
+        return [
+            ...replicas.values()
+        ].some((replica)=>{
+            const head = replica.queue[0];
+            return head !== undefined && refused(outcomes.get(head.id));
+        });
+    }
+    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)
+        });
+        announce();
+    }
     function listed() {
         return [
             ...rooms.values()
@@ -63,11 +103,32 @@ export function createMdRuntime(options) {
     function emitRefusal() {
         for (const listener of refusalListeners)listener(refusal);
     }
-    function moveTo(next) {
+    function emitStorageLoss() {
+        for (const listener of storageLossListeners)listener(storageLoss);
+    }
+    function announce(type = 'changed') {
+        if (applyingRemote || channel === undefined) return;
+        if (type === 'hello') {
+            channel.postMessage({
+                type: 'hello'
+            });
+            return;
+        }
+        channel.postMessage({
+            type,
+            status
+        });
+    }
+    function adopt(next) {
         if (closed || same(status, next)) return;
         status = next;
         for (const listener of statusListeners)listener(status);
     }
+    function moveTo(next) {
+        if (closed || same(status, next)) return;
+        adopt(next);
+        announce();
+    }
     function visible(request) {
         return evaluate(queryRooms(), {
             ...request,
@@ -84,13 +145,18 @@ export function createMdRuntime(options) {
             subscription.notify(visible(subscription.query));
         }
     }
-    function queueOf(locator) {
-        return replicas.get(locator)?.queue ?? [];
+    function entriesOf(locator) {
+        const replica = replicas.get(locator);
+        if (replica === undefined) return [];
+        return replica.queue.map((batch)=>Object.freeze({
+                batch,
+                outcome: queuedOutcome(outcomes.get(batch.id))
+            }));
     }
     function emitQueue(locator) {
-        const batches = queueOf(locator);
+        const entries = entriesOf(locator);
         for (const subscription of queueSubscriptions){
-            if (subscription.locator === locator) subscription.notify(batches);
+            if (subscription.locator === locator) subscription.notify(entries);
         }
     }
     function stopTimer() {
@@ -111,6 +177,7 @@ export function createMdRuntime(options) {
             reason,
             reauthorizationOffered: reason === 'revoked-authorization'
         };
+        journal.record(`connection refused ${reason}`);
         emitRefusal();
     }
     function list(room, synchronizationAvailable) {
@@ -138,8 +205,7 @@ export function createMdRuntime(options) {
         emitRooms();
         return listedLocators;
     }
-    async function open() {
-        const opened = await openReplicaStore();
+    async function hydrate(opened) {
         const [records, queues, kept, lastCompleted, declared] = await Promise.all([
             opened.all(),
             opened.queues(),
@@ -147,27 +213,94 @@ export function createMdRuntime(options) {
             opened.lastCompleted(),
             opened.providerLimits()
         ]);
-        store = opened;
         limits = declared;
+        drafts.clear();
         for (const draft of kept)drafts.set(at(draft.locator, draft.path), draft.content);
-        const queued = new Map(queues.map((queue)=>[
+        const queuedBatches = new Map(queues.map((queue)=>[
                 queue.locator,
                 queue.batches
             ]));
+        outcomes.clear();
+        for (const queue of queues){
+            for (const [id, outcome] of Object.entries(queue.outcomes)){
+                outcomes.set(id, outcome);
+            }
+        }
+        replicas.clear();
         for (const record of records){
             const confirmed = readConfirmed(record);
             if (confirmed === null) continue;
-            replicas.set(record.locator, replicaOf(confirmed, queued.get(record.locator) ?? []));
-            list(record, false);
+            replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? []));
+            const existing = rooms.get(record.locator);
+            if (existing === undefined) list(record, false);
+            else {
+                rooms.set(record.locator, {
+                    ...existing,
+                    roomVersion: record.roomVersion
+                });
+            }
         }
-        moveTo({
-            ...status,
-            lastCompleted
-        });
+        return {
+            lastCompleted,
+            locators: new Set([
+                ...queuedBatches.keys(),
+                ...replicas.keys()
+            ])
+        };
+    }
+    async function readState(opened) {
+        const { lastCompleted, locators } = await hydrate(opened);
         if (replicas.size > 0) {
             emitRooms();
             emitVisible();
         }
+        for (const locator of locators)emitQueue(locator);
+        return lastCompleted;
+    }
+    async function applyRemote(message) {
+        if (closed) return;
+        if (message.type === 'hello') {
+            if (leader) announce();
+            return;
+        }
+        applyingRemote = true;
+        try {
+            const local = await openLocal();
+            const lastCompleted = await readState(local);
+            if (message.status !== undefined) adopt(message.status);
+            else {
+                adopt({
+                    ...status,
+                    lastCompleted,
+                    attentionRequired: attention(),
+                    state: pending() ? 'pending' : status.state
+                });
+            }
+        } finally{
+            applyingRemote = false;
+        }
+        if (message.type === 'enqueue' && leader) void enqueue();
+    }
+    async function open() {
+        const opened = await openReplicaStore();
+        store = opened;
+        await acrossTabs('mdruntime-generation', async ()=>{
+            const storedGeneration = await opened.generation();
+            const loss = detectStorageLoss(storedGeneration);
+            const generation = nextGeneration(storedGeneration);
+            if (generation !== storedGeneration) await opened.rememberGeneration(generation);
+            if (loss !== null) {
+                storageLoss = loss;
+                emitStorageLoss();
+            }
+        });
+        const lastCompleted = await readState(opened);
+        adopt({
+            ...status,
+            lastCompleted,
+            attentionRequired: attention()
+        });
+        if (!leader) announce('hello');
         return opened;
     }
     function openLocal() {
@@ -182,60 +315,234 @@ export function createMdRuntime(options) {
         mutations = next.then(()=>undefined, ()=>undefined);
         return next;
     }
+    function acrossTabs(name, work) {
+        if (typeof window === 'undefined') return work();
+        return window.navigator.locks.request(name, work);
+    }
     function publish(local, room, confirmed) {
         return exclusive(async ()=>{
-            await local.publish(confirmed.record);
-            unreadable.delete(room.locator);
-            replicas.set(room.locator, replicaOf(confirmed, replicas.get(room.locator)?.queue ?? []));
+            await acrossTabs('mdruntime-replica', async ()=>{
+                await hydrate(local);
+                await local.publish(confirmed.record);
+                unreadable.delete(room.locator);
+                replicas.set(room.locator, replicaOf(confirmed, replicas.get(room.locator)?.queue ?? []));
+            });
             list(room, true);
             emitRooms();
             emitVisible();
+            announce();
         });
     }
-    async function write(locator, changes) {
-        const replica = replicas.get(locator);
-        const room = rooms.get(locator);
-        if (replica === undefined || room === undefined) {
-            throw new Error(`No Local Replica for ${locator}`);
-        }
-        const built = buildBatch({
-            baseRoomVersion: replica.confirmed.record.roomVersion,
-            writeGrants: room.writeGrants,
-            providerOwnedPaths: room.providerOwnedPaths,
-            providerLimits: limits,
-            visible: replica.visible,
-            changes
+    async function write(locator, changes, replacing) {
+        const local = await openLocal();
+        const result = await acrossTabs('mdruntime-replica', async ()=>{
+            await hydrate(local);
+            const replica = replicas.get(locator);
+            const room = rooms.get(locator);
+            if (replica === undefined || room === undefined) {
+                throw new Error(`No Local Replica for ${locator}`);
+            }
+            const built = buildBatch({
+                baseRoomVersion: replica.confirmed.record.roomVersion,
+                writeGrants: room.writeGrants,
+                providerOwnedPaths: room.providerOwnedPaths,
+                providerLimits: limits,
+                visible: replica.visible,
+                changes
+            });
+            if (built.kind === 'refused') return {
+                outcome: 'refused',
+                ...built.refusal
+            };
+            const head = replica.queue[0];
+            if (replacing !== undefined) {
+                if (head === undefined || head.id !== replacing || !refused(outcomes.get(head.id))) {
+                    return {
+                        outcome: 'refused',
+                        rule: 'no-refused-head'
+                    };
+                }
+            }
+            const batches = replacing === undefined ? [
+                ...replica.queue,
+                built.batch
+            ] : [
+                built.batch,
+                ...replica.queue.slice(1)
+            ];
+            const consumed = [
+                ...new Set(changes.map((change)=>change.path))
+            ];
+            try {
+                await local.append({
+                    locator,
+                    batches,
+                    outcomes: storedOutcomes(batches)
+                }, consumed);
+            } catch  {
+                return {
+                    outcome: 'refused',
+                    rule: 'durable-write'
+                };
+            }
+            if (replacing !== undefined) outcomes.delete(replacing);
+            for (const path of consumed)drafts.delete(at(locator, path));
+            replicas.set(locator, replicaOf(replica.confirmed, batches));
+            emitQueue(locator);
+            emitVisible();
+            moveTo({
+                ...saving(status),
+                attentionRequired: attention()
+            });
+            return {
+                outcome: 'saved',
+                id: built.batch.id
+            };
         });
-        if (built.kind === 'refused') return {
-            outcome: 'refused',
-            ...built.refusal
-        };
+        if (result.outcome === 'saved') void enqueue();
+        return result;
+    }
+    async function discardHead(locator, identifier) {
         const local = await openLocal();
-        const batches = [
-            ...replica.queue,
-            built.batch
-        ];
-        const consumed = [
-            ...new Set(changes.map((change)=>change.path))
-        ];
-        await local.append({
+        const changed = await acrossTabs('mdruntime-replica', async ()=>{
+            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 false;
+            }
+            const batches = replica.queue.slice(1);
+            outcomes.delete(identifier);
+            await persistQueue(local, locator, batches);
+            replicas.set(locator, replicaOf(replica.confirmed, batches));
+            emitQueue(locator);
+            emitVisible();
+            moveTo({
+                ...status,
+                state: pending() ? 'pending' : status.state,
+                attentionRequired: attention()
+            });
+            return true;
+        });
+        if (changed) void enqueue();
+    }
+    async function readHistory(locator, path, query = {}) {
+        if (closed || refusal !== null) return {
+            kind: 'transport-uncertainty'
+        };
+        try {
+            await ensureAuthorization();
+        } catch  {
+            return {
+                kind: 'transport-uncertainty'
+            };
+        }
+        if (closed || authorization === undefined || refusal !== null) {
+            return {
+                kind: 'transport-uncertainty'
+            };
+        }
+        const transfer = [
+            'transfer',
+            'history',
             locator,
-            batches
-        }, consumed);
-        for (const path of consumed)drafts.delete(at(locator, path));
-        replicas.set(locator, replicaOf(replica.confirmed, batches));
-        emitQueue(locator);
-        emitVisible();
-        moveTo(saving(status));
-        return {
-            outcome: 'saved',
-            id: built.batch.id
+            path
+        ];
+        if (query.revision !== undefined) transfer.push(query.revision);
+        if (query.pageToken !== undefined) transfer.push(query.pageToken);
+        journal.record(transfer.join(' '));
+        try {
+            const result = await options.adapter.history(authorization, {
+                locator,
+                path,
+                ...query.revision === undefined ? {} : {
+                    revision: query.revision
+                },
+                ...query.pageToken === undefined ? {} : {
+                    pageToken: query.pageToken
+                }
+            });
+            journal.record(`outcome history ${result.kind}`);
+            if (result.kind === 'revoked-authorization') refuse('revoked-authorization');
+            return result;
+        } catch  {
+            journal.record('outcome history transport-uncertainty');
+            return {
+                kind: 'transport-uncertainty'
+            };
+        }
+    }
+    function declaredAction(name) {
+        for (const capability of capabilities){
+            for (const action of capability.actions ?? []){
+                if (action.name === name) return action;
+            }
+        }
+        return undefined;
+    }
+    async function invokeAction(name, input) {
+        await ready;
+        if (closed || refusal !== null) return {
+            kind: 'transport-uncertainty'
+        };
+        if (declaredAction(name) === undefined) return {
+            kind: 'undeclared'
         };
+        try {
+            await ensureAuthorization();
+        } catch  {
+            return {
+                kind: 'transport-uncertainty'
+            };
+        }
+        if (closed || authorization === undefined || refusal !== null) {
+            return {
+                kind: 'transport-uncertainty'
+            };
+        }
+        journal.record(`transfer action ${name}`);
+        try {
+            const result = await options.adapter.action(authorization, {
+                name,
+                input
+            });
+            if (result.kind === 'revoked-authorization') refuse('revoked-authorization');
+            journal.record(`outcome action ${result.kind}`);
+            if (result.kind === 'rejected') journal.record(`refusal rejected ${result.text}`);
+            return result;
+        } catch  {
+            journal.record('outcome action transport-uncertainty');
+            return {
+                kind: 'transport-uncertainty'
+            };
+        }
+    }
+    async function pullRefresh(authorized, confirmed) {
+        try {
+            const result = await refreshRoom(options.adapter, authorized, confirmed);
+            const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
+            journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
+            return result;
+        } catch (error) {
+            journal.record(`transfer refresh ${confirmed.record.locator} transport-uncertainty`);
+            throw error;
+        }
+    }
+    async function pullBootstrap(authorized, room) {
+        try {
+            const result = await bootstrapRoom(options.adapter, authorized, room);
+            const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
+            journal.record(`transfer bootstrap ${room.locator} ${detail}`);
+            return result;
+        } catch (error) {
+            journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
+            throw error;
+        }
     }
     async function advance(room, local, authorized) {
         const held = replicas.get(room.locator);
         if (held !== undefined) {
-            const refreshed = await refreshRoom(options.adapter, authorized, held.confirmed);
+            const refreshed = await pullRefresh(authorized, held.confirmed);
             if (refreshed.kind === 'still-current') {
                 if (unreadable.delete(room.locator)) {
                     list(room, true);
@@ -250,62 +557,248 @@ export function createMdRuntime(options) {
             }
             if (refreshed.kind !== 'beyond-horizon') return refreshed;
         }
-        const bootstrapped = await bootstrapRoom(options.adapter, authorized, room);
+        const bootstrapped = await pullBootstrap(authorized, room);
         if (bootstrapped.kind !== 'staged') return bootstrapped;
         if (closed) return unconfirmed;
         await publish(local, room, bootstrapped.confirmed);
         return null;
     }
-    async function synchronize(discovered, local, progress) {
-        for (const room of discovered){
-            if (closed || authorization === undefined) {
+    function recordRefusal(result) {
+        if (result.kind === 'expired') return {
+            kind: 'expired'
+        };
+        if (result.kind === 'conflicted') {
+            return {
+                kind: 'conflicted',
+                roomVersion: result.roomVersion,
+                affected: result.affected,
+                text: result.text
+            };
+        }
+        return {
+            kind: 'rejected',
+            affected: result.affected,
+            text: result.text
+        };
+    }
+    async function commitAccept(room, local, submitted, accepted, base, overlay) {
+        return acrossTabs('mdruntime-replica', async ()=>{
+            await hydrate(local);
+            const current = replicas.get(room.locator);
+            if (current === undefined || !current.queue.some((batch)=>batch.id === submitted.id)) {
+                return true;
+            }
+            const remaining = current.queue.filter((batch)=>batch.id !== submitted.id);
+            const applied = overlay ? applyReturned(base, accepted.documents, accepted.revisions, accepted.removals, accepted.roomVersion) : base;
+            if (applied === null) return false;
+            await local.publish(applied.record);
+            await persistQueue(local, room.locator, remaining);
+            outcomes.set(submitted.id, {
+                kind: 'accepted',
+                roomVersion: accepted.roomVersion,
+                author: accepted.author,
+                time: accepted.time
+            });
+            unreadable.delete(room.locator);
+            replicas.set(room.locator, replicaOf(applied, remaining));
+            list(room, true);
+            emitRooms();
+            emitQueue(room.locator);
+            emitVisible();
+            journal.record(`outcome ${room.locator} ${submitted.id} accepted`);
+            return true;
+        });
+    }
+    async function submitRoom(room, local, authorized, progress) {
+        while(!closed && authorization !== undefined){
+            const replica = replicas.get(room.locator);
+            const head = replica?.queue[0];
+            if (replica === undefined || head === undefined || refused(outcomes.get(head.id))) {
+                return null;
+            }
+            let result;
+            journal.record(`submission ${room.locator} ${head.id}`);
+            try {
+                result = await options.adapter.mutate(authorized, {
+                    locator: room.locator,
+                    changeBatch: head
+                });
+            } catch  {
                 progress.complete = false;
-                return;
+                progress.reachable = false;
+                return null;
             }
-            const withheld = await advance(room, local, authorization);
-            if (withheld === null) continue;
-            progress.complete = false;
-            if (withheld.kind === 'transport-uncertainty') {
+            if (closed) return null;
+            if (result.kind === 'transport-uncertainty') {
+                progress.complete = false;
                 progress.reachable = false;
-                continue;
+                return null;
             }
-            if (withheld.kind === 'room-not-readable') {
+            if (result.kind === 'room-not-readable') {
+                progress.complete = false;
                 unreadable.add(room.locator);
                 list(room, false);
                 emitRooms();
-                continue;
+                return null;
             }
-            if (withheld.kind === 'revoked-authorization') {
+            if (result.kind === 'revoked-authorization') {
                 refuse('revoked-authorization');
+                return 'stop';
+            }
+            if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
+                journal.record(`outcome ${room.locator} ${head.id} ${result.kind}`);
+                if (result.kind !== 'expired') journal.record(`refusal ${result.kind} ${result.text}`);
+                await exclusive(async ()=>{
+                    await acrossTabs('mdruntime-replica', 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);
+                        moveTo({
+                            ...status,
+                            attentionRequired: true
+                        });
+                    });
+                });
+                return null;
+            }
+            const from = replicas.get(room.locator)?.confirmed;
+            if (from === undefined) return null;
+            const pulled = await pullRefresh(authorized, from);
+            if (pulled.kind === 'revoked-authorization') {
+                refuse('revoked-authorization');
+                return 'stop';
+            }
+            if (pulled.kind === 'still-current') {
+                const committed = await exclusive(()=>commitAccept(room, local, head, result, from, true));
+                if (!committed) {
+                    progress.complete = false;
+                    return null;
+                }
+                continue;
+            }
+            if (pulled.kind === 'advanced') {
+                const overlay = pulled.confirmed.record.roomVersion === result.roomVersion;
+                const committed = await exclusive(()=>commitAccept(room, local, head, result, pulled.confirmed, overlay));
+                if (!committed) {
+                    progress.complete = false;
+                    return null;
+                }
+                continue;
+            }
+            if (pulled.kind === 'beyond-horizon') {
+                const bootstrapped = await pullBootstrap(authorized, room);
+                if (bootstrapped.kind === 'revoked-authorization') {
+                    refuse('revoked-authorization');
+                    return 'stop';
+                }
+                if (bootstrapped.kind === 'staged') {
+                    const overlay = bootstrapped.confirmed.record.roomVersion === result.roomVersion;
+                    const committed = await exclusive(()=>commitAccept(room, local, head, result, bootstrapped.confirmed, overlay));
+                    if (!committed) {
+                        progress.complete = false;
+                        return null;
+                    }
+                    continue;
+                }
+                progress.complete = false;
+                if (bootstrapped.kind === 'transport-uncertainty') {
+                    progress.reachable = false;
+                } else if (bootstrapped.kind === 'room-not-readable') {
+                    unreadable.add(room.locator);
+                    list(room, false);
+                    emitRooms();
+                }
+                return null;
+            }
+            progress.complete = false;
+            if (pulled.kind === 'transport-uncertainty') {
+                progress.reachable = false;
+            } else if (pulled.kind === 'room-not-readable') {
+                unreadable.add(room.locator);
+                list(room, false);
+                emitRooms();
+            }
+            return null;
+        }
+        return null;
+    }
+    async function synchronize(discovered, local, progress) {
+        for (const room of discovered){
+            if (closed || authorization === undefined) {
+                progress.complete = false;
                 return;
             }
+            const withheld = await advance(room, local, authorization);
+            if (withheld !== null) {
+                progress.complete = false;
+                if (withheld.kind === 'transport-uncertainty') {
+                    progress.reachable = false;
+                    continue;
+                }
+                if (withheld.kind === 'room-not-readable') {
+                    unreadable.add(room.locator);
+                    list(room, false);
+                    emitRooms();
+                    continue;
+                }
+                if (withheld.kind === 'revoked-authorization') {
+                    refuse('revoked-authorization');
+                    return;
+                }
+                continue;
+            }
+            if (await submitRoom(room, local, authorization, progress) === 'stop') return;
         }
     }
     async function cycle(local, progress) {
-        if (closed || authorization === undefined) return;
+        if (closed || authorization === undefined) {
+            notifyReady();
+            return;
+        }
         moveTo(transferring(status));
-        const result = await options.adapter.discover(authorization);
-        if (closed) return;
+        let result;
+        try {
+            result = await options.adapter.discover(authorization);
+        } catch (error) {
+            journal.record('connection discover transport-uncertainty');
+            notifyReady();
+            throw error;
+        }
+        if (closed) {
+            notifyReady();
+            return;
+        }
+        journal.record(`connection discover ${result.kind}`);
         if (result.kind === 'transport-uncertainty') {
             progress.reachable = false;
+            notifyReady();
             return;
         }
         if (result.kind === 'revoked-authorization') {
             refuse('revoked-authorization');
+            notifyReady();
             return;
         }
         if (!result.supportedVersions.includes(ROOM_CONTRACT_VERSION)) {
             refuse('no-matching-version');
+            notifyReady();
             return;
         }
         if (result.mdModel.identity !== MD_MODEL.identity || result.mdModel.version !== MD_MODEL.version) {
             refuse('md-model-version-mismatch');
+            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');
+                notifyReady();
                 return;
             }
         }
@@ -313,6 +806,8 @@ export function createMdRuntime(options) {
             refusal = null;
             emitRefusal();
         }
+        capabilities = result.capabilities;
+        notifyReady();
         if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits)) {
             limits = result.providerLimits;
             await local.declare(limits);
@@ -325,10 +820,19 @@ export function createMdRuntime(options) {
     }
     async function ensureAuthorization() {
         if (authorization !== undefined) return;
-        authorization = await options.adapter.authorize();
+        try {
+            authorization = await options.adapter.authorize();
+            journal.record('connection authorize');
+        } catch (error) {
+            journal.record('connection authorize transport-uncertainty');
+            throw error;
+        }
     }
     async function connect() {
-        if (closed || discoveryPaused) return;
+        if (closed || discoveryPaused) {
+            notifyReady();
+            return;
+        }
         startTimer();
         const progress = {
             complete: false,
@@ -348,9 +852,11 @@ export function createMdRuntime(options) {
             }
         } catch  {
             progress.complete = false;
+            notifyReady();
             return;
         } finally{
-            moveTo(settled(status, progress, completedAt, pending()));
+            notifyReady();
+            moveTo(settled(status, progress, completedAt, pending(), attention()));
         }
     }
     async function run() {
@@ -365,6 +871,10 @@ export function createMdRuntime(options) {
         }
     }
     function enqueue() {
+        if (!leader) {
+            announce('enqueue');
+            return chain;
+        }
         if (inflight) {
             queued = true;
             return chain;
@@ -373,21 +883,54 @@ export function createMdRuntime(options) {
         chain = chain.then(run, run);
         return chain;
     }
+    function startProcessing() {
+        if (leader) {
+            void enqueue();
+            return;
+        }
+        void window.navigator.locks.request('mdruntime-sync', {
+            signal: options.signal
+        }, async ()=>{
+            if (closed) return;
+            leader = true;
+            announce();
+            void enqueue();
+            await new Promise((resolve)=>{
+                releaseLeadership = ()=>{
+                    leader = false;
+                    resolve();
+                };
+            });
+        }).catch(()=>{});
+    }
     function close() {
         closed = true;
         stopTimer();
+        releaseLeadership();
+        channel?.close();
         store?.close();
         roomListeners.clear();
         refusalListeners.clear();
+        storageLossListeners.clear();
         statusListeners.clear();
         querySubscriptions.clear();
         queueSubscriptions.clear();
     }
+    channel?.addEventListener('message', (event)=>{
+        const data = event.data;
+        if (data === null || typeof data !== 'object') return;
+        void exclusive(()=>applyRemote(data));
+    });
     options.signal?.addEventListener('abort', close, {
         once: true
     });
     if (options.signal?.aborted) close();
-    void enqueue();
+    void openLocal().then(()=>{
+        if (!leader) notifyReady();
+    }, ()=>{
+        notifyReady();
+    });
+    startProcessing();
     return {
         rooms () {
             return listed();
@@ -420,8 +963,35 @@ export function createMdRuntime(options) {
                 drafts.delete(at(locator, path));
             }
         },
-        save (locator, changes) {
-            return exclusive(()=>write(locator, changes));
+        save (locator, changes, replacing) {
+            return exclusive(()=>write(locator, changes, replacing));
+        },
+        outcome (identifier) {
+            const recorded = outcomes.get(identifier);
+            if (recorded !== undefined) return recorded;
+            for (const replica of replicas.values()){
+                if (replica.queue.some((batch)=>batch.id === identifier)) return {
+                    kind: 'pending'
+                };
+            }
+            return null;
+        },
+        queue: {
+            discard (locator, identifier) {
+                return exclusive(()=>discardHead(locator, identifier));
+            }
+        },
+        history (locator, path, query) {
+            return readHistory(locator, path, query);
+        },
+        call (name, input) {
+            return invokeAction(name, input);
+        },
+        log () {
+            return journal.export();
+        },
+        storageLoss () {
+            return storageLoss;
         },
         observe (topic, second, third) {
             if (topic === 'rooms') {
@@ -440,6 +1010,14 @@ export function createMdRuntime(options) {
                     refusalListeners.delete(notify);
                 };
             }
+            if (topic === 'storage-loss') {
+                const notify = second;
+                storageLossListeners.add(notify);
+                notify(storageLoss);
+                return ()=>{
+                    storageLossListeners.delete(notify);
+                };
+            }
             if (topic === 'sync-status') {
                 const notify = second;
                 statusListeners.add(notify);
@@ -454,7 +1032,7 @@ export function createMdRuntime(options) {
                     notify: third
                 };
                 queueSubscriptions.add(queue);
-                queue.notify(queueOf(queue.locator));
+                queue.notify(entriesOf(queue.locator));
                 return ()=>{
                     queueSubscriptions.delete(queue);
                 };
@@ -472,6 +1050,7 @@ export function createMdRuntime(options) {
         },
         async reauthorize () {
             if (refusal === null || !refusal.reauthorizationOffered) return;
+            journal.record('connection reauthorize');
             authorization = undefined;
             discoveryPaused = false;
             await enqueue();