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

package/dist/connection.js

@@ -1,55 +1,74 @@
-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 { attachedModel } from './attached-model.js';
+import { cached, modelTypes, NO_MODEL, sameModel, } from './model.js';
+import { observing } from './observation.js';
+import { filterOf, identityOf, planOf, } from './query.js';
+import { createReadSide } from './read-side.js';
+import { markdownPath, roomOfKey } from './rows.js';
+import { createSearchIndex, searchPlanOf, } from './search.js';
 import { bootstrapRoom } from './bootstrap.js';
-import { createConversationStore } from './conversation.js';
-import { MD_MODEL, PRESENTED, validRoot } from './collection.js';
+import { changeSet, mergeChangeSets } from './change-set.js';
+import { createConversationStore, } from './conversation.js';
+import { queuedFile } from './change.js';
+import { validRoot } from './collection.js';
+import { runtimeError } from './failure.js';
 import { createLog } from './log.js';
-import { queuedOutcome, refusalOf, refused, withheldUntilReset } from './outcome.js';
+import { binaryRecord } from './binary.js';
+import { absentBinary, binaryAnswer, calledResult, failure, historyAnswer, undeclared, UNCERTAIN, } from './outcome.js';
 import { refreshRoom } from './refresh.js';
-import { buildBatch } from './save.js';
-import { applyReturned, compositionOf, readConfirmed, replicaOf } from './replica.js';
-import { settled, same, saving, STARTING, transferring } from './status.js';
+import { buildBatch, joined, limitedIn, requeued } from './save.js';
+import { applyReturned, compositionOf, confirmedOf, landed, readReclassified, replicaOf, sameMembership, withdrawals, } from './replica.js';
+import { binaryBase, changedParts, changesOf, held, heldFile, joinedDraft, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
+import { same, saving, STARTING, transferring, } from './status.js';
 import { detectStorageLoss, nextGeneration } from './durability.js';
-import { beneath } from './paths.js';
-import { openRuntimeStore } from './store.js';
+import { FencedMap } from './fence.js';
+import { roomDraftRevision } from './identity.js';
+import { beneath, normalize } from './paths.js';
+import { openRuntimeStore, } from './store.js';
 import { unconfirmed } from './transfer.js';
-const DEFAULT_DISCOVERY_INTERVAL_MS = 60_000;
-const knownCapabilities = new Set(VERSION_1_CAPABILITIES);
+import { governs, holds, narrowed, planReach, } from './reach.js';
 function within(root, path) {
     return root === '' || beneath(root, path);
 }
-function declaredIdentity(model) {
-    if (model === undefined) return false;
-    if (model === null) return true;
-    return typeof model.identity === 'string' && model.identity.length > 0 && typeof model.version === 'string' && model.version.length > 0;
-}
 function declaredSelection(room) {
     const selection = room.typedSelection;
-    if (selection === undefined) return true;
-    if (!Array.isArray(selection.roots) || selection.roots.length === 0) return false;
-    if (!declaredIdentity(selection.attachedModel)) return false;
-    return selection.roots.every((root, index)=>validRoot(root) && root !== '' && !within(room.collectionRoot, root) && selection.roots.every((other, at)=>at === index || !within(other, root)));
+    if (selection === undefined)
+        return true;
+    if (!Array.isArray(selection.roots) || selection.roots.length === 0)
+        return false;
+    return selection.roots.every((root, index) => validRoot(root) &&
+        root !== '' &&
+        selection.roots.every((other, at) => at === index || !within(other, root)));
 }
-export function createMdRuntime(options) {
-    const period = options.discoveryIntervalMs ?? DEFAULT_DISCOVERY_INTERVAL_MS;
+export function composeRuntime(options) {
+    const localSaves = options.adapter.localSaves === true;
     let authorization = options.authorization;
     let opening;
     let store;
-    const replicas = new Map();
-    const drafts = new Map();
+    const fences = new Map();
+    const isFenced = (locator) => fences.has(locator);
+    let fencings = 0;
+    const lastFenced = new Map();
+    const fencedSince = (locator, since) => fences.has(locator) || (lastFenced.get(locator) ?? 0) > since;
+    let discoveries = 0;
+    const replicas = new FencedMap(isFenced);
+    const queuesWithoutReplica = new FencedMap(isFenced);
+    const pendings = new Map();
+    const roomDrafts = new FencedMap(isFenced);
     const presentations = new Map();
-    const outcomes = new Map();
     let limits = [];
     let capabilities = [];
-    const rooms = new Map();
+    const rooms = new FencedMap(isFenced);
+    const counted = new Map();
     const unreadable = new Set();
-    const models = new Map();
-    const liveModels = new Map();
+    const isModelFenced = (key) => isFenced(key.slice(key.indexOf(' ') + 1));
+    const models = new FencedMap(isModelFenced);
+    const liveModels = new FencedMap(isModelFenced);
     const invalidModels = new Set();
-    const modelEpoch = new Map();
     const discovered = new Map();
+    let roomsListed = false;
     const scopedRefusals = new Map();
+    const sourceRefusals = new Map();
+    const declarationRefusals = new Set();
     function modelKey(locator, attached) {
         return `${attached} ${locator}`;
     }
@@ -57,326 +76,433 @@ export function createMdRuntime(options) {
         return models.get(modelKey(locator, attached)) ?? NO_MODEL;
     }
     function savedModel(locator, attached) {
-        return invalidModels.has(modelKey(locator, attached)) ? {
-            status: 'unavailable',
-            reason: 'revoked'
-        } : modelOf(locator, attached);
+        return invalidModels.has(modelKey(locator, attached))
+            ? { status: 'unavailable', reason: 'revoked' }
+            : modelOf(locator, attached);
     }
     function compositionFor(record) {
         return compositionOf({
             ...record,
             model: savedModel(record.locator, 'collection'),
-            selectionModel: savedModel(record.locator, 'typed-selection')
+            selectionModel: savedModel(record.locator, 'typed-selection'),
         });
     }
-    const mismatchedRoots = new Set();
     let refusal = null;
     let storageLoss = null;
     let status = STARTING;
+    let shown = STARTING;
     let discoveryPaused = false;
-    let timer;
+    let resetTimer;
     let closed = false;
-    let withdrawNotifications;
-    let handed;
-    const notices = new Map();
+    let stopping = false;
+    let withdrawStream;
+    const announced = new Map();
+    let underway = null;
+    let streamed = null;
+    let handed = false;
+    const submitting = new Map();
+    const answering = new Map();
+    let complete = false;
+    let recorded = false;
+    const stale = new Set();
     let chain = Promise.resolve();
     let mutations = Promise.resolve();
-    let inflight = false;
-    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 draftListeners = new Set();
+    const roomDraftListeners = new Set();
     const presentationListeners = new Set();
+    const readSide = createReadSide();
     let withdrawConversations;
+    let currencyQueued = false;
+    let socketOpen = false;
+    let serviceMode = 'open';
+    let haltedRefusal = false;
+    let openSignals = 0;
+    const serviceModeListeners = new Set();
+    let member = null;
+    const memberListeners = new Set();
+    const materialized = new Set();
+    let everyRoom = false;
+    const transfers = new FencedMap(isFenced);
     const conversations = createConversationStore({
-        cards: declaredCards,
-        documents: ()=>visible({}),
-        call: (name, input)=>invokeAction(name, input),
+        agents: declaredAgents,
+        documents: (locator) => rowsQuery(planOf({ rooms: [locator], select: 'all' }, roomFacts())),
+        call: (name, input) => invokeAction(name, input),
         durably,
-        path: ()=>options.adapter.conversations,
-        closed: ()=>closed
+        stream: () => options.adapter.conversations,
+        publish: publishChangeSet,
+        closed: () => closed,
+    });
+    const searchIndex = createSearchIndex({
+        documents: () => readSide.documents(),
+        document: (room, path) => readSide.document(room, path),
+        messages: () => conversations.messages(),
+        message: (conversation, identity) => conversations.message(conversation, identity),
     });
     const journal = createLog();
-    let notifyReady = ()=>{};
-    const ready = new Promise((resolve)=>{
+    let notifyReady = () => { };
+    const ready = new Promise((resolve) => {
         notifyReady = resolve;
     });
-    function draftContent(locator, path) {
-        return drafts.get(locator)?.get(path);
-    }
-    function rememberDraft(locator, path, content) {
-        const room = drafts.get(locator) ?? new Map();
-        room.set(path, content);
-        drafts.set(locator, room);
-    }
-    function forgetDraft(locator, path) {
-        const room = drafts.get(locator);
-        if (room === undefined) return;
+    function rememberRoomDraft(record) {
+        const room = roomDrafts.get(record.locator) ?? new Map();
+        room.set(record.path, record);
+        roomDrafts.set(record.locator, room);
+    }
+    function forgetRoomDraft(locator, path) {
+        const room = roomDrafts.get(locator);
+        if (room === undefined)
+            return;
         room.delete(path);
-        if (room.size === 0) drafts.delete(locator);
+        if (room.size === 0)
+            roomDrafts.delete(locator);
+    }
+    function roomDraftOf(record) {
+        return structuredClone({
+            room: record.locator,
+            path: record.path,
+            revision: record.revision,
+            parts: record.parts,
+            changedUnderneath: underneath(record.parts, record.path, replicas.get(record.locator)?.visible),
+            returned: record.returned,
+        });
     }
-    function snapshotDrafts() {
-        const entries = [];
-        for (const [locator, room] of drafts){
-            for (const [path, content] of room){
-                entries.push({
-                    locator,
-                    path,
-                    content: structuredClone(content)
-                });
-            }
-        }
-        entries.sort((left, right)=>{
-            if (left.locator !== right.locator) return left.locator < right.locator ? -1 : 1;
-            if (left.path !== right.path) return left.path < right.path ? -1 : 1;
+    function snapshotRoomDrafts() {
+        const records = [...roomDrafts.values()].flatMap((room) => [...room.values()]);
+        records.sort((left, right) => {
+            if (left.locator !== right.locator)
+                return left.locator < right.locator ? -1 : 1;
+            if (left.path !== right.path)
+                return left.path < right.path ? -1 : 1;
             return 0;
         });
-        return entries;
-    }
-    async function readDrafts(opened) {
-        await hydrate(opened);
-        return snapshotDrafts();
+        return records.map(roomDraftOf);
     }
-    function publishDrafts(waitingOnly) {
-        if (closed) return;
-        const value = snapshotDrafts();
-        for (const listener of draftListeners){
-            if (waitingOnly && listener.ready) continue;
+    function publishRoomDrafts(waitingOnly) {
+        if (closed)
+            return;
+        const value = snapshotRoomDrafts();
+        for (const listener of roomDraftListeners) {
+            if (waitingOnly && listener.ready)
+                continue;
             listener.ready = true;
             listener.notify(value);
         }
     }
-    function emitDrafts() {
-        publishDrafts(false);
-    }
-    function releaseWaitingDrafts() {
-        publishDrafts(true);
-    }
     function presentationOf(app) {
         const value = presentations.get(app);
         return value === undefined ? null : structuredClone(value);
     }
     function emitPresentation(app) {
-        if (closed) return;
-        for (const listener of presentationListeners){
-            if (listener.app === app && listener.ready) listener.notify(presentationOf(app));
+        if (closed)
+            return;
+        for (const listener of presentationListeners) {
+            if (listener.app === app && listener.ready)
+                listener.notify(presentationOf(app));
         }
     }
-    function commitDraft(work) {
-        return exclusive(async ()=>{
-            const local = await openLocal();
-            await hydrate(local);
-            await work(local);
-        }).then(()=>{
-            emitDrafts();
-        });
-    }
     function pending() {
-        return [
-            ...replicas.values()
-        ].some((replica)=>replica.queue.length > 0);
+        return (!localSaves &&
+            (queuesWithoutReplica.size > 0 ||
+                [...replicas.values()].some((replica) => replica.queue.length > 0)));
     }
     function attention() {
         const attentionRequired = [];
-        let reset = null;
-        for (const [locator, replica] of replicas){
-            const head = replica.queue[0];
-            if (head === undefined) continue;
-            const outcome = outcomes.get(head.id);
-            if (outcome?.kind === 'retryable-refusal') {
-                if (outcome.reset !== undefined && (reset === null || outcome.reset < reset)) {
-                    reset = outcome.reset;
-                }
+        for (const record of [...roomDrafts.values()].flatMap((room) => [...room.values()])) {
+            if (record.returned === null)
                 continue;
-            }
-            if (!refused(outcome)) continue;
             attentionRequired.push({
-                locator,
-                batch: head.id,
-                outcome: outcome.kind,
-                refusal: refusalOf(outcome),
-                ...outcome.kind === 'conflicted' && outcome.roomVersion !== undefined ? {
-                    roomVersion: outcome.roomVersion
-                } : {}
+                room: record.locator,
+                path: record.path,
+                returned: structuredClone(record.returned),
             });
         }
-        return {
-            attentionRequired,
-            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;
+        attentionRequired.sort((left, right) => {
+            if (left.room !== right.room)
+                return left.room < right.room ? -1 : 1;
+            if (left.path !== right.path)
+                return left.path < right.path ? -1 : 1;
+            return 0;
+        });
+        let reset = null;
+        for (const { submission } of pendings.values()) {
+            if (submission.state !== 'reset')
+                continue;
+            if (reset === null || submission.reset < reset)
+                reset = submission.reset;
         }
-        return stored;
+        return { attentionRequired, reset };
     }
-    async function persistQueue(local, locator, batches) {
-        await local.writeQueue({
-            locator,
-            batches,
-            outcomes: storedOutcomes(batches)
-        });
+    function documentsIn(locator) {
+        const replica = replicas.get(locator);
+        if (replica === undefined)
+            return 0;
+        const roots = replica.confirmed.record.typedSelection?.roots ?? [];
+        const paths = [
+            ...Object.keys(replica.visible.documents).filter(markdownPath),
+            ...Object.keys(replica.visible.binaries),
+        ];
+        return paths.filter((path) => !roots.some((root) => beneath(root, path))).length;
     }
     function listed() {
-        return structuredClone([
-            ...rooms.values()
-        ]);
-    }
-    function queryRooms() {
-        return [
-            ...replicas.values()
-        ].map((replica)=>({
-                room: replica.confirmed.record.locator,
-                roomVersion: replica.confirmed.record.roomVersion,
-                documents: replica.visible.collection.documents,
-                model: modelTypes(modelOf(replica.confirmed.record.locator)),
-                typedSelection: replica.confirmed.record.typedSelection === null ? null : modelTypes(modelOf(replica.confirmed.record.locator, 'typed-selection'))
-            }));
+        return structuredClone([...rooms.values()].map((room) => {
+            const documents = documentsIn(room.locator);
+            counted.set(room.locator, documents);
+            return { ...room, documents };
+        }));
+    }
+    function roomFacts(reach = null) {
+        const held = [...rooms.values()]
+            .filter((room) => holds(reach, room.locator))
+            .map((room) => {
+            const governed = governs(reach, room);
+            const attached = [
+                ...(governed.collection ? [modelOf(room.locator)] : []),
+                ...(governed.selection ? [modelOf(room.locator, 'typed-selection')] : []),
+            ];
+            return {
+                locator: room.locator,
+                available: attached.every((model) => model.status !== 'unavailable'),
+                types: attached.flatMap((model) => model.status === 'unavailable' ? [] : Object.values(model.types)),
+            };
+        });
+        return { listed: roomsListed, rooms: held };
     }
     function emitRooms() {
         const value = listed();
-        for (const listener of roomListeners)listener(value);
+        for (const listener of roomListeners)
+            listener(value);
     }
     function emitRefusal() {
-        for (const listener of refusalListeners)listener(refusal);
+        for (const listener of refusalListeners)
+            listener(refusal);
     }
     function emitStorageLoss() {
-        for (const listener of storageLossListeners)listener(storageLoss);
+        for (const listener of storageLossListeners)
+            listener(storageLoss);
+    }
+    function emitMember() {
+        for (const listener of memberListeners)
+            listener(member);
     }
     function moveTo(next) {
-        if (closed || same(status, next)) return;
+        if (closed)
+            return;
         status = next;
-        for (const listener of statusListeners)listener(status);
-    }
-    function visible(request) {
-        if (options.queryBinding === null) {
-            if (Object.keys(request).length > 0) throw new Error('query-binding-unavailable');
-            return rawQuery(queryRooms());
-        }
-        return options.queryBinding(queryRooms(), {
-            ...request,
-            selector: {
-                $and: [
-                    PRESENTED,
-                    request.selector ?? {}
-                ]
-            }
-        });
+        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 emitVisible() {
-        for (const subscription of querySubscriptions){
-            subscription.notify(visible(subscription.query));
+    function entryOf(batch) {
+        if (localSaves)
+            return Object.freeze({ batch, state: 'local' });
+        const state = pendings.get(batch.id);
+        if (state?.accepted !== undefined) {
+            return Object.freeze({ batch, state: 'accepted', roomVersion: state.accepted });
         }
+        return Object.freeze({ batch, ...(state?.submission ?? { state: 'waiting' }) });
     }
     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))
-            }));
+        return (replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? []).map(entryOf);
     }
     function emitQueue(locator) {
         const entries = entriesOf(locator);
-        for (const subscription of queueSubscriptions){
-            if (subscription.locator === locator) subscription.notify(entries);
+        for (const subscription of queueSubscriptions) {
+            if (subscription.locator === locator)
+                subscription.notify(entries);
         }
     }
-    function stopTimer() {
-        if (timer === undefined) return;
-        clearInterval(timer);
-        timer = undefined;
-    }
-    function startTimer() {
-        if (timer !== undefined) return;
-        timer = setInterval(()=>{
-            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)
-                }
-            });
+    function applyChangeSet(set) {
+        const held = everyRoom
+            ? set
+            : { ...set, documents: set.documents.filter(({ locator }) => materialized.has(locator)) };
+        readSide.apply(held);
+        searchIndex.changed(held);
+    }
+    function materialize(locators) {
+        if (everyRoom)
+            return;
+        if (locators === null)
+            everyRoom = true;
+        const sets = [];
+        for (const locator of locators ?? [...replicas.keys()]) {
+            if (materialized.has(locator))
+                continue;
+            materialized.add(locator);
+            const replica = replicas.get(locator);
+            if (replica !== undefined)
+                sets.push(changeSet(locator, null, replica));
+        }
+        if (sets.length === 0)
+            return;
+        const set = mergeChangeSets(sets);
+        readSide.apply(set);
+        searchIndex.changed(set);
+    }
+    function reachedRooms(plan) {
+        if (plan.rooms !== null)
+            return plan.rooms;
+        if (plan.reach === null)
+            return null;
+        return [...plan.reach.rooms, ...plan.reach.documents.map(roomOfKey)];
+    }
+    function rowsQuery(plan) {
+        materialize(reachedRooms(plan));
+        return readSide.query(plan);
+    }
+    function publishChangeSet(set) {
+        applyChangeSet(set);
+        if (set.rooms.length > 0 ||
+            [...new Set(set.documents.map(({ locator }) => locator))].some((locator) => rooms.has(locator) && counted.get(locator) !== documentsIn(locator)))
             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');
-            });
+        for (const locator of set.queues)
+            emitQueue(locator);
+        if (set.drafts.length > 0 ||
+            set.documents.some((change) => roomDrafts.get(change.locator)?.has(change.path) === true)) {
+            publishRoomDrafts(false);
+        }
+        for (const app of set.presentations)
+            emitPresentation(app);
+        conversations.changed(set);
+    }
+    function stopTimer() {
+        if (resetTimer === undefined)
+            return;
+        clearTimeout(resetTimer);
+        resetTimer = undefined;
+    }
+    function armTimer() {
+        stopTimer();
+        if (closed || stopping)
+            return;
+        let earliest = null;
+        for (const { submission } of pendings.values()) {
+            if (submission.state !== 'reset')
+                continue;
+            const at = Date.parse(submission.reset);
+            if (earliest === null || at < earliest)
+                earliest = at;
         }
+        if (earliest === null)
+            return;
+        // A Save House held back goes again only once the reset its answer named has passed.
+        resetTimer = setTimeout(() => {
+            resetTimer = undefined;
+            submitAll();
+        }, Math.max(0, earliest - Date.now()));
+    }
+    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) => replica.confirmed.record));
+                    }
+                    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);
+                        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,
+                            };
+                            replicas.set(locator, replicaOf(confirmedOf(record, before.confirmed), before.queue, 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 }));
+                    }
+                    publishChangeSet(mergeChangeSets(changed));
+                });
+            }
+        }
+        finally {
+            refusal = {
+                code: reason,
+                retryable: false,
+                reauthorizationOffered: reason === 'revoked-authorization',
+                refusal: provider,
+            };
+            journal.record(`connection refused ${reason}`);
+            emitRefusal();
+        }
     }
     function list(room, synchronizationAvailable) {
         const selection = room.typedSelection ?? null;
         rooms.set(room.locator, {
             name: room.name,
-            collectionRoot: room.collectionRoot,
             locator: room.locator,
+            handle: room.handle,
             operations: room.operations,
             replica: room.replica,
-            attachedModel: room.attachedModel,
             model: modelTypes(modelOf(room.locator)),
-            typedSelection: selection === null ? null : {
-                roots: selection.roots,
-                attachedModel: selection.attachedModel,
-                model: modelTypes(modelOf(room.locator, 'typed-selection'))
-            },
+            typedSelection: selection === null
+                ? null
+                : {
+                    roots: selection.roots,
+                    model: modelTypes(modelOf(room.locator, 'typed-selection')),
+                },
             providerOwnedPaths: room.providerOwnedPaths,
             roomVersion: replicas.get(room.locator)?.confirmed.record.roomVersion ?? null,
             synchronizationAvailable,
-            refusal: scopedRefusals.get(room.locator) ?? null
+            refusal: scopedRefusals.get(room.locator) ?? sourceRefusals.get(room.locator) ?? null,
         });
     }
-    function applyDiscovery(listed) {
-        const listedLocators = new Set(listed.map((room)=>room.locator));
-        for (const locator of listedLocators)scopedRefusals.delete(locator);
+    async function applyDiscovery(found, started) {
+        for (const room of found) {
+            const fence = fences.get(room.locator);
+            if (fence !== undefined && fence.erased && fence.at < started)
+                fences.delete(room.locator);
+        }
+        const listed = found.filter((room) => !fences.has(room.locator));
+        const listedLocators = new Set(listed.map((room) => room.locator));
+        for (const locator of listedLocators)
+            scopedRefusals.delete(locator);
         discovered.clear();
-        for (const room of listed)discovered.set(room.locator, room);
-        for (const room of listed){
+        for (const room of listed)
+            discovered.set(room.locator, room);
+        const unlisted = unlistedHeld(new Set(found.map((room) => room.locator)));
+        if (options.adapter.exhaustiveDiscovery === true)
+            await loseRooms(unlisted);
+        else
+            unlistedKept(unlisted);
+        for (const room of listed) {
             const held = replicas.get(room.locator)?.confirmed.record;
             if (held !== undefined && held.replica.selection !== room.replica.selection) {
                 list(held, false);
@@ -384,23 +510,93 @@ export function createMdRuntime(options) {
             }
             list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
         }
-        for (const [locator, room] of rooms){
-            if (listedLocators.has(locator)) continue;
-            rooms.set(locator, {
-                ...room,
-                synchronizationAvailable: false
-            });
-        }
+        roomsListed = true;
         emitRooms();
-        return listedLocators;
+        return listed;
+    }
+    function unlistedHeld(listed) {
+        return [
+            ...new Set([
+                ...rooms.keys(),
+                ...roomDrafts.keys(),
+                ...transfers.keys(),
+                ...queuesWithoutReplica.keys(),
+            ]),
+        ].filter((locator) => !listed.has(locator));
+    }
+    function unlistedKept(unlisted) {
+        for (const locator of unlisted) {
+            const held = replicas.get(locator)?.confirmed.record;
+            if (held !== undefined)
+                list(held, false);
+            else
+                rooms.delete(locator);
+        }
+    }
+    function fence(locators) {
+        const fresh = [...new Set(locators)].filter((locator) => !fences.has(locator));
+        const removed = fresh.map((locator) => changeSet(locator, replicas.get(locator) ?? null, null, {
+            room: true,
+            queue: true,
+            drafts: [...(roomDrafts.get(locator)?.keys() ?? [])],
+        }));
+        for (const locator of fresh) {
+            fences.set(locator, { at: discoveries, erased: false });
+            lastFenced.set(locator, ++fencings);
+            for (const batch of replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? [])
+                pendings.delete(batch.id);
+            replicas.delete(locator);
+            queuesWithoutReplica.delete(locator);
+            rooms.delete(locator);
+            roomDrafts.delete(locator);
+            transfers.delete(locator);
+            discovered.delete(locator);
+            announced.delete(locator);
+            unreadable.delete(locator);
+            stale.delete(locator);
+            scopedRefusals.delete(locator);
+            sourceRefusals.delete(locator);
+            declarationRefusals.delete(locator);
+            for (const attached of ['collection', 'typed-selection']) {
+                const key = modelKey(locator, attached);
+                models.delete(key);
+                liveModels.delete(key);
+                invalidModels.delete(key);
+            }
+            journal.record(`room lost ${locator}`);
+        }
+        if (fresh.length === 0)
+            return fresh;
+        publishChangeSet(mergeChangeSets(removed));
+        for (const locator of fresh)
+            materialized.delete(locator);
+        moveTo({ ...status, ...attention() });
+        return fresh;
+    }
+    async function erased(local, locators) {
+        await local.erase(locators);
+        for (const locator of locators) {
+            const held = fences.get(locator);
+            if (held !== undefined)
+                held.erased = true;
+        }
+    }
+    async function loseRooms(locators) {
+        const fresh = fence(locators);
+        if (fresh.length > 0)
+            await durably((local) => erased(local, fresh));
     }
     function restored(key, persisted) {
         const prior = models.get(key);
-        if (prior !== undefined && prior.status !== 'unavailable' && (persisted.status === 'unavailable' || !sameModel(prior.snapshot, persisted.snapshot))) {
-            modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
+        if (prior !== undefined &&
+            prior.status !== 'unavailable' &&
+            (persisted.status === 'unavailable' || !sameModel(prior.snapshot, persisted.snapshot))) {
             invalidModels.add(key);
         }
-        const model = persisted.status === 'unavailable' || liveModels.get(key) === JSON.stringify(persisted.snapshot) ? persisted : cached(persisted);
+        const model = persisted.status === 'unavailable' ||
+            liveModels.get(key) === JSON.stringify(persisted.snapshot)
+            ? persisted
+            : cached(persisted);
         models.set(key, model);
         if (model.status === 'unavailable') {
             liveModels.delete(key);
@@ -409,108 +605,125 @@ export function createMdRuntime(options) {
         return model;
     }
     async function hydrate(opened) {
-        const [records, queues, kept, presented, cached, unsent, lastCompleted, declared] = await Promise.all([
+        const [records, queues, kept, presented, held, chatDrafts, lastCompleted, declared, named, known, staged,] = await Promise.all([
             opened.all(),
             opened.queues(),
-            opened.drafts(),
+            opened.roomDrafts(),
             opened.presentation(),
             opened.conversations(),
-            opened.instructions(),
+            opened.chatDrafts(),
             opened.lastCompleted(),
-            opened.providerLimits()
+            opened.providerLimits(),
+            opened.capabilities(),
+            opened.member(),
+            opened.transfers(),
         ]);
+        transfers.clear();
+        for (const record of staged)
+            transfers.set(record.locator, record);
         limits = declared;
-        drafts.clear();
-        for (const draft of kept)rememberDraft(draft.locator, draft.path, draft.content);
+        capabilities = named;
+        member = known;
+        roomDrafts.clear();
+        for (const record of kept)
+            rememberRoomDraft(record);
         presentations.clear();
-        for (const record of presented)presentations.set(record.app, record.value);
-        conversations.hydrate(cached, unsent);
-        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);
-            }
-        }
+        for (const record of presented)
+            presentations.set(record.app, record.value);
+        conversations.hydrate(held, chatDrafts);
+        const queuedBatches = new Map(queues.map((queue) => [queue.locator, queue.pending.map(({ batch }) => batch)]));
+        pendings.clear();
+        for (const queue of queues) {
+            for (const { batch, state } of queue.pending)
+                pendings.set(batch.id, state);
+        }
+        const previousReplicas = new Map(replicas);
         replicas.clear();
-        for (const record of records){
+        queuesWithoutReplica.clear();
+        const replicated = new Set(records.map((record) => record.locator));
+        for (const [locator, queue] of queuedBatches) {
+            if (!replicated.has(locator))
+                queuesWithoutReplica.set(locator, queue);
+        }
+        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 confirmed = readConfirmed({
-                ...record,
-                model,
-                selectionModel
-            });
-            if (confirmed === null) continue;
-            replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? []));
+            const prior = previousReplicas.get(record.locator);
+            const confirmed = confirmedOf({ ...record, model, selectionModel }, prior?.confirmed);
+            replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? [], prior));
             const existing = rooms.get(record.locator);
-            if (existing === undefined) list(record, false);
+            if (existing === undefined)
+                list(record, false);
             else {
                 rooms.set(record.locator, {
                     ...existing,
                     roomVersion: record.roomVersion,
                     operations: record.operations,
                     replica: record.replica,
-                    attachedModel: record.attachedModel,
                     model: modelTypes(model),
-                    typedSelection: record.typedSelection === null ? null : {
-                        roots: record.typedSelection.roots,
-                        attachedModel: record.typedSelection.attachedModel,
-                        model: modelTypes(selectionModel)
-                    }
+                    typedSelection: record.typedSelection === null
+                        ? null
+                        : {
+                            roots: record.typedSelection.roots,
+                            model: modelTypes(selectionModel),
+                        },
                 });
             }
         }
         return {
             lastCompleted,
-            locators: new Set([
-                ...queuedBatches.keys(),
-                ...replicas.keys()
-            ])
+            locators: new Set([...queuedBatches.keys(), ...replicas.keys()]),
+            read: mergeChangeSets([...new Set([...previousReplicas.keys(), ...replicas.keys()])].map((locator) => changeSet(locator, previousReplicas.get(locator) ?? null, replicas.get(locator) ?? null))),
         };
     }
     async function readState(opened) {
-        const { lastCompleted, locators } = await hydrate(opened);
-        if (replicas.size > 0) {
+        const { lastCompleted, locators, read } = await hydrate(opened);
+        applyChangeSet(read);
+        if (replicas.size > 0)
             emitRooms();
-            emitVisible();
-        }
-        for (const locator of locators)emitQueue(locator);
-        emitDrafts();
+        if (member !== null)
+            emitMember();
+        for (const locator of locators)
+            emitQueue(locator);
+        publishRoomDrafts(false);
         return lastCompleted;
     }
     async function open() {
-        const opened = await openRuntimeStore();
+        if (closed)
+            throw new Error('runtime closed');
+        const opened = await openRuntimeStore(isFenced);
         store = opened;
+        const interrupted = await opened.fences();
+        for (const locator of interrupted) {
+            fences.set(locator, { at: discoveries, erased: false });
+            lastFenced.set(locator, ++fencings);
+        }
         const kept = options.shell.generation;
         const storedGeneration = await opened.generation();
         const loss = detectStorageLoss(storedGeneration, kept);
         const generation = nextGeneration(storedGeneration, kept);
-        if (generation !== storedGeneration) await opened.rememberGeneration(generation);
-        if (generation !== kept) await options.shell.keepGeneration(generation);
+        if (generation !== storedGeneration)
+            await opened.rememberGeneration(generation);
+        if (generation !== kept)
+            await options.shell.keepGeneration(generation);
         if (loss !== null) {
             storageLoss = loss;
             emitStorageLoss();
         }
         const lastCompleted = await readState(opened);
-        moveTo({
-            ...status,
-            lastCompleted,
-            ...attention()
-        });
+        if (interrupted.length > 0)
+            await erased(opened, interrupted);
+        moveTo({ ...status, lastCompleted, ...attention() });
         return opened;
     }
     function durably(work) {
-        return exclusive(async ()=>{
+        return exclusive(async () => {
             const local = await openLocal();
-            await hydrate(local);
             return work(local);
         });
     }
     function openLocal() {
-        opening ??= open().catch((error)=>{
+        opening ??= open().catch((error) => {
             opening = undefined;
             throw error;
         });
@@ -518,247 +731,560 @@ export function createMdRuntime(options) {
     }
     function exclusive(work) {
         const next = mutations.then(work, work);
-        mutations = next.then(()=>undefined, ()=>undefined);
+        mutations = next.then(() => undefined, () => undefined);
         return next;
     }
-    function publish(local, room, confirmed) {
-        return exclusive(async ()=>{
-            await hydrate(local);
-            const retained = readConfirmed({
-                ...confirmed.record,
-                model: modelOf(room.locator),
-                selectionModel: modelOf(room.locator, 'typed-selection')
+    function withdrawable(batch) {
+        const state = pendings.get(batch.id);
+        return state !== undefined && state.submission.state !== 'submitted' && !state.lost;
+    }
+    async function settle(local, locator, before, confirmed, queue, settling = {}) {
+        const previousQueue = before?.queue ?? queuesWithoutReplica.get(locator) ?? [];
+        const withdrawn = withdrawals(confirmed, queue, withdrawable, localSaves);
+        const kept = queue.filter((batch) => !withdrawn.includes(batch));
+        const unqueued = withdrawn.map((batch) => ({
+            batch,
+            returned: localSaves || landed(batch, confirmed) ? null : returnedBy('withdrawn'),
+        }));
+        const returning = [
+            ...[...unqueued].reverse(),
+            ...(settling.leaving === undefined ? [] : [settling.leaving]),
+        ];
+        const written = new Map();
+        for (const { batch, returned } of returning) {
+            if (returned === null)
+                continue;
+            for (const saved of pendings.get(batch.id)?.drafts ?? []) {
+                const existing = written.get(saved.path) ?? roomDrafts.get(locator)?.get(saved.path);
+                written.set(saved.path, {
+                    locator,
+                    path: saved.path,
+                    revision: roomDraftRevision(),
+                    parts: returnedInto(existing?.parts, saved.parts),
+                    returned,
+                });
+            }
+        }
+        await local.keepAuthored({ locator, queue: kept, roomDrafts: [...written.values()] });
+        for (const batch of previousQueue) {
+            if (!kept.includes(batch))
+                pendings.delete(batch.id);
+        }
+        for (const record of written.values())
+            rememberRoomDraft(record);
+        try {
+            await local.write({
+                next: confirmed.record,
+                previous: before?.confirmed.record ?? null,
+                ...(settling.stored === undefined ? {} : { stored: settling.stored }),
             });
-            if (retained !== null) {
-                await local.publish(retained.record);
-                unreadable.delete(room.locator);
-                replicas.set(room.locator, replicaOf(retained, replicas.get(room.locator)?.queue ?? []));
+        }
+        catch (error) {
+            const held = before === undefined ? null : replicaOf(before.confirmed, kept, before);
+            if (held !== null)
+                replicas.set(locator, held);
+            else if (kept.length > 0)
+                queuesWithoutReplica.set(locator, kept);
+            else
+                queuesWithoutReplica.delete(locator);
+            publishChangeSet(changeSet(locator, before ?? null, held, {
+                queue: kept.length !== previousQueue.length,
+                drafts: [...written.keys()],
+            }));
+            moveTo({ ...status, ...attention() });
+            throw error;
+        }
+        queuesWithoutReplica.delete(locator);
+        for (const { batch, returned } of unqueued) {
+            const outcome = localSaves ? 'dropped' : returned === null ? 'landed' : 'withdrawn';
+            journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
+        }
+        replicas.set(locator, replicaOf(confirmed, kept, before));
+        return changeSet(locator, before ?? null, replicas.get(locator) ?? null, {
+            room: settling.room,
+            queue: kept.length !== previousQueue.length,
+            drafts: [...written.keys()],
+        });
+    }
+    function adoptModels(locator, record) {
+        for (const [attached, model] of [
+            ['collection', record.model],
+            ['typed-selection', record.selectionModel],
+        ]) {
+            const key = modelKey(locator, attached);
+            models.set(key, model);
+            invalidModels.delete(key);
+            if (model.status === 'current')
+                liveModels.set(key, JSON.stringify(model.snapshot));
+            else if (model.status === 'unavailable')
+                liveModels.delete(key);
+        }
+    }
+    function remodel(locator, answers, held) {
+        const taken = (answer, previous, attached) => {
+            if (answer === undefined)
+                return previous;
+            const { state, refused } = attachedModel(answer, previous);
+            if (refused !== null) {
+                const where = refused.location === undefined ? '' : ` ${refused.location}`;
+                journal.record(`model invalid ${locator} ${attached} ${refused.identity} ${refused.rule}${where}`);
+            }
+            models.set(modelKey(locator, attached), state);
+            return state;
+        };
+        return {
+            collection: taken(answers?.collection, held.collection, 'collection'),
+            selection: taken(answers?.selection, held.selection, 'typed-selection'),
+        };
+    }
+    function publish(local, room, confirmed, landing = {}) {
+        const { base, stored } = landing;
+        return exclusive(async () => {
+            if (!continuing())
+                return true;
+            const prior = replicas.get(room.locator);
+            if (base !== undefined &&
+                (prior?.confirmed.record.roomVersion !== base.record.roomVersion ||
+                    prior.confirmed.record.revisions !== base.record.revisions)) {
+                return false;
             }
+            adoptModels(room.locator, confirmed.record);
+            const queue = prior?.queue ?? queuesWithoutReplica.get(room.locator) ?? [];
+            const roomVersion = confirmed.record.roomVersion;
+            const accepted = queue.filter((batch) => {
+                const accepted = pendings.get(batch.id)?.accepted;
+                return (accepted !== undefined && options.adapter.reached(room.locator, roomVersion, accepted));
+            });
+            const set = await settle(local, room.locator, prior, confirmed, queue.filter((batch) => !accepted.includes(batch)), { room: true, ...(stored === undefined ? {} : { stored }) });
+            if (stored !== undefined)
+                transfers.delete(room.locator);
+            for (const batch of accepted)
+                pendings.delete(batch.id);
+            stale.delete(room.locator);
+            if (unreadable.delete(room.locator))
+                scopedRefusals.delete(room.locator);
+            sourceRefusals.delete(room.locator);
+            declarationRefusals.delete(room.locator);
             list(room, true);
-            emitRooms();
-            emitVisible();
+            publishChangeSet(set);
+            moveTo({ ...status, ...attention() });
+            return true;
         });
     }
-    async function write(locator, changes, replacing) {
+    async function saveRoomDrafts(locator, named, writtenBy) {
         const local = await openLocal();
-        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}`);
+            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
         }
-        if (mismatchedRoots.has(locator)) return {
-            outcome: 'refused',
-            rule: 'collection-root-mismatch'
-        };
-        const built = buildBatch({
+        const saved = [];
+        for (const { path, revision } of named) {
+            const record = roomDrafts.get(locator)?.get(path);
+            if (record === undefined || record.revision !== revision) {
+                return { outcome: 'refused', code: 'stale', retryable: false, file: path };
+            }
+            if (!saved.some((draft) => draft.path === path))
+                saved.push({ path, parts: record.parts });
+        }
+        const changed = saved.flatMap(({ path, parts }) => changedParts(path, underneath(parts, path, replica.visible)));
+        if (changed.length > 0)
+            return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
+        const parts = saved.map(({ path, parts }) => changesOf(path, parts));
+        const changes = parts.flatMap(({ changes }) => changes);
+        const requeue = requeued(replica.queue, changes, replica.visible, withdrawable, (queue) => replicaOf(replica.confirmed, queue, replica).visible);
+        if (requeue.kind === 'refused')
+            return { outcome: 'refused', ...requeue.refusal };
+        const foreign = [...requeue.withdrawn.keys()].some((origin) => {
+            const writer = replica.queue.find((batch) => batch.id === origin)?.writtenBy;
+            return writer?.app !== writtenBy?.app || writer?.release !== writtenBy?.release;
+        });
+        if (foreign) {
+            return {
+                outcome: 'refused',
+                code: 'unknown-revision',
+                retryable: false,
+                file: [...requeue.queued].at(-1),
+            };
+        }
+        const withdrawing = requeue.withdrawn.size > 0;
+        const input = {
+            local: localSaves,
             baseRoomVersion: replica.confirmed.record.roomVersion,
             composition: compositionFor(replica.confirmed.record),
             operations: room.operations,
-            binding: options.modelBinding,
             providerOwnedPaths: room.providerOwnedPaths,
             providerLimits: limits,
+            handle: room.handle,
             visible: replica.visible,
-            changes
-        });
-        if (built.kind === 'refused') return {
-            outcome: 'refused',
-            ...built.refusal
+            changes,
+            bases: parts.flatMap(({ bases }) => bases),
+            writtenBy,
         };
-        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  {
+        const checked = withdrawing ? buildBatch({ ...input, queued: requeue.queued }) : null;
+        if (checked?.kind === 'refused')
+            return { outcome: 'refused', ...checked.refusal };
+        const owners = [...requeue.owners].flatMap((origin) => {
+            const batch = requeue.withdrawn.get(origin);
+            return batch === undefined || batch === null ? [] : [{ origin, batch }];
+        });
+        if (owners.length > 1) {
             return {
                 outcome: 'refused',
-                rule: 'durable-write'
+                code: 'unknown-revision',
+                retryable: false,
+                file: [...requeue.queued].at(-1),
             };
         }
-        if (replacing !== undefined) outcomes.delete(replacing);
-        for (const path of consumed)forgetDraft(locator, path);
-        replicas.set(locator, replicaOf(replica.confirmed, batches));
-        emitQueue(locator);
-        emitVisible();
-        emitDrafts();
-        moveTo({
-            ...saving(status),
-            ...attention()
-        });
-        void enqueue();
-        return {
-            outcome: 'saved',
-            id: built.batch.id
-        };
-    }
-    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))) {
+        const built = !withdrawing
+            ? buildBatch(input)
+            : requeue.changes.length === 0
+                ? null
+                : buildBatch({
+                    ...input,
+                    visible: replicaOf(replica.confirmed, requeue.queue, replica).visible,
+                    changes: requeue.changes,
+                });
+        if (built?.kind === 'refused')
+            return { outcome: 'refused', ...built.refusal };
+        const [owner] = owners;
+        const join = built === null || owner === undefined
+            ? null
+            : joined(requeue.queue, owner.batch, built.batch);
+        if (join?.kind === 'refused')
+            return { outcome: 'refused', ...join.refusal };
+        const withdrawn = new Map(requeue.withdrawn);
+        if (join !== null && owner !== undefined)
+            withdrawn.set(owner.origin, join.batch);
+        const drafted = new Map();
+        for (const [origin, replaced] of withdrawn) {
+            if (replaced === null)
+                continue;
+            const carried = withdrawnDrafts(pendings.get(origin)?.drafts ?? [], changes);
+            drafted.set(replaced.id, replaced === join?.batch
+                ? [
+                    ...carried.map((held) => joinedDraft(held, saved)),
+                    ...saved.filter((draft) => !carried.some((held) => held.path === draft.path)),
+                ]
+                : carried);
+        }
+        if (built !== null && join === null)
+            drafted.set(built.batch.id, saved);
+        const batches = join !== null ? join.queue : built === null ? requeue.queue : [...requeue.queue, built.batch];
+        for (const replaced of withdrawn.values()) {
+            if (replaced === null || !batches.includes(replaced))
+                continue;
+            const limited = limitedIn(batches, replaced, limits, (queue) => replicaOf(replica.confirmed, queue, replica).visible);
+            if (limited !== null)
+                return { outcome: 'refused', ...limited };
+        }
+        const consumed = saved.map(({ path }) => path);
+        try {
+            await local.keepAuthored({
+                locator,
+                queue: batches,
+                saved: drafted,
+                consumedRoomDrafts: consumed,
+            });
+        }
+        catch {
+            return { outcome: 'refused', code: 'durable-write', retryable: true };
+        }
+        if (fences.has(locator))
+            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
+        for (const origin of withdrawn.keys())
+            pendings.delete(origin);
+        for (const [id, drafts] of drafted) {
+            pendings.set(id, { drafts, submission: { state: 'waiting' }, lost: false });
+        }
+        if (!localSaves)
+            recorded = false;
+        for (const path of consumed)
+            forgetRoomDraft(locator, path);
+        replicas.set(locator, replicaOf(replica.confirmed, batches, replica));
+        publishChangeSet(changeSet(locator, replica, replicas.get(locator) ?? null, {
+            queue: true,
+            drafts: consumed,
+        }));
+        moveTo({ ...(localSaves ? status : saving(status)), ...attention() });
+        submitLater(locator);
+        const identifier = join?.batch.id ??
+            built?.batch.id ??
+            [...requeue.withdrawn].map(([origin, replaced]) => replaced?.id ?? origin).at(-1);
+        return { outcome: 'saved', identifier };
+    }
+    async function mark(local, locator, identifier, submission, lost) {
+        const state = pendings.get(identifier);
+        if (!continuing() ||
+            state === undefined ||
+            (JSON.stringify(state.submission) === JSON.stringify(submission) && state.lost === lost)) {
             return;
         }
-        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,
-            ...attention()
-        });
-        void enqueue();
+        await local.submit(locator, identifier, submission, lost);
+        if (fences.has(locator))
+            return;
+        pendings.set(identifier, { ...state, submission, lost });
+        const replica = replicas.get(locator);
+        if (replica !== undefined)
+            publishChangeSet(changeSet(locator, replica, replica, { queue: true }));
+        moveTo({ ...status, ...attention() });
+    }
+    async function keepUpload(local, locator, identifier, upload) {
+        if (!continuing())
+            throw new Error('connection refused');
+        await local.keepUpload(locator, identifier, upload);
+        if (fences.has(locator))
+            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
+        pendings.set(identifier, { ...pendings.get(identifier), upload });
+        if (!continuing())
+            throw new Error('connection refused');
     }
     async function readHistory(locator, path, query = {}) {
-        if (closed || refusal !== null) return {
-            kind: 'transport-uncertainty'
-        };
+        if (closed || refusal !== null)
+            return UNCERTAIN;
         try {
             await ensureAuthorization();
-        } catch  {
-            return {
-                kind: 'transport-uncertainty'
-            };
-        }
-        if (closed || authorization === undefined || refusal !== null) {
-            return {
-                kind: 'transport-uncertainty'
-            };
         }
-        const transfer = [
-            'transfer',
-            'history',
-            locator,
-            path
-        ];
-        if (query.revision !== undefined) transfer.push(query.revision);
-        if (query.pageToken !== undefined) transfer.push(query.pageToken);
+        catch {
+            return UNCERTAIN;
+        }
+        if (closed || authorization === undefined || refusal !== null)
+            return UNCERTAIN;
+        const since = fencings;
+        const transfer = ['transfer', 'history', locator, 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
-                }
+                ...(query.revision === undefined ? {} : { revision: query.revision }),
+                ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
             });
             journal.record(`outcome history ${result.kind}`);
+            if (fencedSince(locator, since))
+                return failure({ kind: 'room-not-readable', locator });
             if (result.kind === 'scoped-refusal') {
                 const room = replicas.get(result.locator)?.confirmed.record;
-                if (room !== undefined) await scoped(result, room, await openLocal());
+                if (room !== undefined)
+                    await scoped(result, room, await openLocal());
             }
-            if (result.kind === 'revoked-authorization') refuse('revoked-authorization');
-            return result;
-        } catch  {
+            if (result.kind === 'revoked-authorization')
+                await refuse('revoked-authorization');
+            return historyAnswer(result);
+        }
+        catch {
             journal.record('outcome history transport-uncertainty');
-            return {
-                kind: 'transport-uncertainty'
-            };
+            return UNCERTAIN;
+        }
+    }
+    function queuedBlob(locator, path, localId) {
+        for (const batch of replicas.get(locator)?.queue ?? []) {
+            const change = batch.changes[queuedFile(batch, path, localId)];
+            if (change?.kind === 'binary')
+                return change.blob;
         }
+        return null;
+    }
+    function binaryRoom(request) {
+        if (request.kind === 'path')
+            return request.locator;
+        const scope = options.adapter.referrerScope(request.referrer);
+        return scope?.kind === 'room' ? scope.locator : null;
+    }
+    async function readBinary(request) {
+        if (closed || refusal !== null)
+            return UNCERTAIN;
+        try {
+            await ensureAuthorization();
+        }
+        catch {
+            return UNCERTAIN;
+        }
+        if (closed || authorization === undefined || refusal !== null)
+            return UNCERTAIN;
+        const since = fencings;
+        journal.record(request.kind === 'path'
+            ? `transfer binary ${request.locator} ${request.path}`
+            : `transfer binary ${request.fileRef}`);
+        try {
+            const result = await options.adapter.binary(authorization, request);
+            journal.record(`outcome binary ${result.kind}`);
+            const locator = binaryRoom(request);
+            if (locator !== null && fencedSince(locator, since))
+                return failure({ kind: 'room-not-readable', locator });
+            if (result.kind === 'scoped-refusal') {
+                const room = replicas.get(result.locator)?.confirmed.record;
+                if (room !== undefined)
+                    await scoped(result, room, await openLocal());
+            }
+            if (result.kind === 'revoked-authorization')
+                await refuse('revoked-authorization');
+            return binaryAnswer(result);
+        }
+        catch {
+            journal.record('outcome binary transport-uncertainty');
+            return UNCERTAIN;
+        }
+    }
+    async function readBinaryPath(locator, path, revision) {
+        await ready;
+        if (revision !== undefined)
+            return readBinary({ kind: 'path', locator, path, revision });
+        const visible = replicas.get(locator)?.visible;
+        const held = visible?.binaries[path];
+        if (visible === undefined || held === undefined)
+            return absentBinary(path);
+        if (held.state === 'pending') {
+            const blob = queuedBlob(locator, path, held.localId);
+            return blob === null ? absentBinary(path) : { kind: 'binary', blob };
+        }
+        const record = binaryRecord(path, held, visible.revisions[path]);
+        if (record.state !== 'accepted')
+            return absentBinary(path);
+        const replica = replicas.get(locator);
+        const queued = (replica?.queue ?? []).flatMap((batch) => batch.changes);
+        const holds = (at) => {
+            const kept = replica?.confirmed.record.binaries[at];
+            return (kept?.state === 'accepted' &&
+                kept.fileRef === record.fileRef &&
+                replica?.confirmed.record.revisions[at] === record.revision);
+        };
+        let confirmed = path;
+        for (let index = queued.length - 1; index >= 0 && !holds(confirmed); index -= 1) {
+            const change = queued[index];
+            if (change.kind === 'move' && change.to === confirmed)
+                confirmed = change.path;
+        }
+        return readBinary({
+            kind: 'path',
+            locator,
+            path: confirmed,
+            revision: record.revision,
+            fileRef: record.fileRef,
+        });
+    }
+    async function readBinaryReference(reference) {
+        await ready;
+        return readBinary({
+            kind: 'reference',
+            fileRef: reference.fileRef,
+            referrer: reference.referrer,
+        });
     }
-    function declaredCards() {
-        for (const capability of capabilities){
-            if (capability.conversationCards !== undefined) return capability.conversationCards;
+    function declaredAgents() {
+        for (const capability of capabilities) {
+            if (capability.conversationAgents !== undefined)
+                return capability.conversationAgents;
         }
         return undefined;
     }
     function declaredAction(name) {
-        for (const capability of capabilities){
-            for (const action of capability.actions ?? []){
-                if (action.name === name) return action;
+        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'
-        };
+        if (closed || refusal !== null)
+            return UNCERTAIN;
+        if (declaredAction(name) === undefined)
+            return undeclared(name);
         try {
             await ensureAuthorization();
-        } catch  {
-            return {
-                kind: 'transport-uncertainty'
-            };
         }
-        if (closed || authorization === undefined || refusal !== null) {
-            return {
-                kind: 'transport-uncertainty'
-            };
+        catch {
+            return UNCERTAIN;
         }
+        if (closed || authorization === undefined || refusal !== null)
+            return UNCERTAIN;
         journal.record(`transfer action ${name}`);
         try {
-            const result = await options.adapter.action(authorization, {
-                name,
-                input
-            });
+            const result = await options.adapter.action(authorization, { name, input });
             if (result.kind === 'scoped-refusal') {
                 const room = replicas.get(result.locator)?.confirmed.record;
-                if (room !== undefined) await scoped(result, room, await openLocal());
+                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;
-        } catch  {
+            if (result.kind === 'rejected')
+                journal.record(`refusal rejected ${result.code}`);
+            return calledResult(result);
+        }
+        catch {
             journal.record('outcome action transport-uncertainty');
-            return {
-                kind: 'transport-uncertainty'
-            };
+            return UNCERTAIN;
         }
     }
+    function continuing() {
+        return !closed && !discoveryPaused;
+    }
+    function reachedBy(locator, roomVersion) {
+        const held = replicas.get(locator);
+        return (held !== undefined &&
+            options.adapter.reached(locator, held.confirmed.record.roomVersion, roomVersion));
+    }
+    function writtenAfter(locator, roomVersion, path) {
+        const written = replicas.get(locator)?.confirmed.record.written[path];
+        return (written !== undefined &&
+            options.adapter.reached(locator, written, roomVersion) &&
+            !options.adapter.reached(locator, roomVersion, written));
+    }
     async function pullRefresh(authorized, confirmed) {
+        if (!continuing())
+            return unconfirmed;
         try {
-            const result = await refreshRoom(options.adapter, authorized, confirmed, options.modelBinding);
+            const result = await refreshRoom(options.adapter, authorized, confirmed, (models, held) => remodel(confirmed.record.locator, models, held), continuing);
             const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
             return result;
-        } catch (error) {
+        }
+        catch (error) {
             journal.record(`transfer refresh ${confirmed.record.locator} transport-uncertainty`);
             throw error;
         }
     }
-    async function pullBootstrap(authorized, room) {
+    function staging(local) {
+        return {
+            held: (locator) => transfers.get(locator) ?? null,
+            staged: (record) => local.staged(record),
+            stage: (record, page) => exclusive(async () => {
+                if (!continuing())
+                    return false;
+                await local.stage(record, page);
+                transfers.set(record.locator, record);
+                return true;
+            }),
+            abandon: (locator) => exclusive(async () => {
+                if (!continuing())
+                    return;
+                await local.abandon(locator);
+                transfers.delete(locator);
+            }),
+        };
+    }
+    async function pullBootstrap(authorized, room, local) {
+        if (!continuing())
+            return unconfirmed;
         try {
             const result = await bootstrapRoom(options.adapter, authorized, room, {
                 collection: modelOf(room.locator),
-                selection: modelOf(room.locator, 'typed-selection')
-            }, options.modelBinding);
+                selection: modelOf(room.locator, 'typed-selection'),
+            }, (models, held) => remodel(room.locator, models, held), continuing, staging(local));
             const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
             return result;
-        } catch (error) {
+        }
+        catch (error) {
             journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
             throw error;
         }
@@ -767,276 +1293,343 @@ export function createMdRuntime(options) {
         const held = replicas.get(room.locator);
         if (held !== undefined) {
             const refreshed = await pullRefresh(authorized, held.confirmed);
+            if (!continuing())
+                return unconfirmed;
             if (refreshed.kind === 'still-current') {
+                stale.delete(room.locator);
+                if (sourceRefusals.has(room.locator))
+                    return null;
                 if (unreadable.delete(room.locator)) {
+                    scopedRefusals.delete(room.locator);
                     list(room, true);
                     emitRooms();
                 }
                 return null;
             }
             if (refreshed.kind === 'advanced') {
-                if (closed) return unconfirmed;
-                await publish(local, room, refreshed.confirmed);
+                if (!(await publish(local, room, refreshed.confirmed, { base: held.confirmed }))) {
+                    const now = replicas.get(room.locator)?.confirmed.record.roomVersion;
+                    const reached = now !== undefined &&
+                        options.adapter.reached(room.locator, now, refreshed.confirmed.record.roomVersion);
+                    return reached ? null : advance(room, local, authorized);
+                }
+                await retainModel(local, room, 'collection', modelOf(room.locator));
                 return null;
             }
-            if (refreshed.kind !== 'beyond-horizon') return refreshed;
-        }
-        const bootstrapped = await pullBootstrap(authorized, room);
-        if (bootstrapped.kind !== 'staged') return bootstrapped;
-        if (closed) return unconfirmed;
-        await publish(local, room, bootstrapped.confirmed);
+            if (refreshed.kind !== 'beyond-horizon')
+                return refreshed;
+        }
+        const bootstrapped = await pullBootstrap(authorized, room, local);
+        if (!continuing())
+            return unconfirmed;
+        if (bootstrapped.kind !== 'staged')
+            return bootstrapped;
+        await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored });
         return null;
     }
-    function recordRefusal(result) {
-        if (result.kind === 'expired') return {
-            kind: 'expired'
-        };
-        if (result.kind === 'retryable-refusal') {
-            return {
-                kind: 'retryable-refusal',
-                code: result.code,
-                fields: result.fields,
-                ...result.reset === undefined ? {} : {
-                    reset: result.reset
-                }
-            };
+    async function withhold(withheld, room, local, progress) {
+        if (withheld.kind === 'refused')
+            stale.delete(room.locator);
+        else
+            stale.add(room.locator);
+        if (withheld.kind === 'scoped-refusal') {
+            await scoped(withheld, room, local);
         }
-        if (result.kind === 'conflicted') {
-            return {
-                kind: 'conflicted',
-                ...result.roomVersion === undefined ? {} : {
-                    roomVersion: result.roomVersion
-                },
-                affected: result.affected,
-                code: result.code,
-                fields: result.fields
-            };
+        else if (withheld.kind === 'transport-uncertainty') {
+            progress.reachable = false;
+        }
+        else if (withheld.kind === 'retryable-refusal') {
+            journal.record(`refusal ${withheld.kind} ${withheld.code}`);
+        }
+        else if (withheld.kind === 'room-not-readable') {
+            unreadable.add(room.locator);
+            list(room, false);
+            emitRooms();
+        }
+        else if (withheld.kind === 'refused') {
+            refusedSource(room, withheld);
+        }
+        else if (withheld.kind === 'revoked-authorization') {
+            await refuse('revoked-authorization');
         }
+    }
+    function refusedSource(room, { refusal }) {
+        sourceRefusals.set(room.locator, {
+            code: refusal.rule,
+            retryable: false,
+            fields: {
+                file: refusal.file,
+                ...(refusal.location === undefined ? {} : { location: refusal.location }),
+                ...(refusal.referrers === undefined ? {} : { referrers: refusal.referrers }),
+            },
+        });
+        declarationRefusals.delete(room.locator);
+        unreadable.add(room.locator);
+        list(room, false);
+        emitRooms();
+        journal.record(`source refused ${room.locator} ${refusal.rule} ${refusal.file}`);
+    }
+    function leaving(batch, result) {
+        if (result.kind === 'expired')
+            return { batch, returned: returnedBy('expired') };
         return {
-            kind: 'rejected',
-            affected: result.affected,
-            code: result.code,
-            fields: result.fields
+            batch,
+            returned: {
+                kind: result.kind,
+                code: result.code,
+                fields: result.fields,
+                retryable: result.retryable,
+            },
         };
     }
-    async function commitAccept(room, local, submitted, accepted, base, overlay) {
-        await hydrate(local);
+    function logAccepted(locator, submitted, accepted) {
+        journal.record(`outcome ${locator} ${submitted.id} accepted ${accepted.roomVersion}` +
+            (accepted.author === undefined ? '' : ` author ${accepted.author}`) +
+            (accepted.time === undefined ? '' : ` time ${accepted.time}`));
+    }
+    async function adoptAccepted(room, local, submitted, accepted) {
+        if (!continuing())
+            return unconfirmed;
         const current = replicas.get(room.locator);
-        if (current === undefined || !current.queue.some((batch)=>batch.id === submitted.id)) {
-            return true;
+        if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
+            return null;
         }
-        const remaining = current.queue.filter((batch)=>batch.id !== submitted.id);
-        const retainedBase = readConfirmed({
-            ...base.record,
-            model: modelOf(room.locator),
-            selectionModel: modelOf(room.locator, 'typed-selection')
-        });
-        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);
-        outcomes.set(submitted.id, {
-            kind: 'accepted',
-            roomVersion: accepted.roomVersion,
-            ...accepted.author === undefined ? {} : {
-                author: accepted.author
-            },
-            ...accepted.time === undefined ? {} : {
-                time: accepted.time
-            }
-        });
+        const held = current.confirmed.record.roomVersion;
+        logAccepted(room.locator, submitted, accepted);
+        const applied = options.adapter.reached(room.locator, held, accepted.roomVersion)
+            ? { kind: 'staged', confirmed: current.confirmed }
+            : applyReturned(current.confirmed, submitted, accepted, options.adapter.follows(room.locator, held, accepted.roomVersion)
+                ? accepted.roomVersion
+                : held, accepted.roomVersion);
+        if (applied.kind !== 'staged') {
+            const state = pendings.get(submitted.id);
+            await local.accept(room.locator, submitted.id, accepted.roomVersion);
+            if (state !== undefined && !fences.has(room.locator))
+                pendings.set(submitted.id, { ...state, accepted: accepted.roomVersion });
+            emitQueue(room.locator);
+            return applied;
+        }
+        const set = await settle(local, room.locator, current, applied.confirmed, current.queue.filter((batch) => batch.id !== submitted.id), { room: true });
+        pendings.delete(submitted.id);
         unreadable.delete(room.locator);
-        replicas.set(room.locator, replicaOf(applied, remaining));
+        sourceRefusals.delete(room.locator);
+        declarationRefusals.delete(room.locator);
         list(room, true);
-        emitRooms();
-        emitQueue(room.locator);
-        emitVisible();
-        journal.record(`outcome ${room.locator} ${submitted.id} accepted ${accepted.roomVersion}` + (accepted.author === undefined ? '' : ` author ${accepted.author}`) + (accepted.time === undefined ? '' : ` time ${accepted.time}`));
-        return true;
+        publishChangeSet(set);
+        moveTo({ ...status, ...attention() });
+        return null;
+    }
+    async function adopted(room, local, submitted, accepted) {
+        const failed = await exclusive(() => adoptAccepted(room, local, submitted, accepted));
+        if (failed === null)
+            return true;
+        if (failed.kind === 'refused' && continuing())
+            refusedSource(room, failed);
+        return false;
     }
     async function submitRoom(room, local, authorized, progress) {
-        while(!closed && authorization !== undefined){
+        while (continuing() && authorization !== undefined) {
             const replica = replicas.get(room.locator);
             const head = replica?.queue[0];
-            if (replica === undefined || head === undefined) return null;
-            const held = outcomes.get(head.id);
-            if (refused(held)) return null;
-            if (held?.kind === 'retryable-refusal') {
-                if (withheldUntilReset(held, Date.now())) {
-                    progress.complete = false;
-                    return null;
-                }
-                await exclusive(async ()=>{
-                    await hydrate(local);
-                    const current = replicas.get(room.locator);
-                    if (current === undefined || current.queue[0]?.id !== head.id) return;
-                    outcomes.delete(head.id);
-                    await persistQueue(local, room.locator, current.queue);
-                    emitQueue(room.locator);
-                    moveTo({
-                        ...status,
-                        ...attention()
-                    });
-                });
+            if (replica === undefined || head === undefined)
+                return;
+            if (pendings.get(head.id)?.accepted !== undefined)
+                return;
+            const state = pendings.get(head.id);
+            const { submission, lost: earlier } = state ?? {
+                submission: { state: 'waiting' },
+                lost: false,
+            };
+            if (submission.state === 'reset' && Date.now() < Date.parse(submission.reset)) {
+                progress.complete = false;
+                return;
+            }
+            if (writesHeld()) {
+                progress.complete = false;
+                journal.record(`submission ${room.locator} ${head.id} held`);
+                return;
             }
+            const lost = earlier || submission.state === 'submitted';
             let result;
             journal.record(`submission ${room.locator} ${head.id}`);
+            await exclusive(() => mark(local, room.locator, head.id, { state: 'submitted' }, lost));
+            if (discoveryPaused || fences.has(room.locator))
+                return;
+            if (writesHeld()) {
+                await exclusive(() => mark(local, room.locator, head.id, submission, earlier));
+                progress.complete = false;
+                journal.record(`submission ${room.locator} ${head.id} held`);
+                return;
+            }
+            const opensBefore = openSignals;
+            const answered = awaitingAnswer(room.locator);
             try {
                 result = await options.adapter.mutate(authorized, {
                     locator: room.locator,
-                    changeBatch: head
-                });
-            } catch  {
+                    changeBatch: head,
+                    ...(state?.upload === undefined ? {} : { upload: state.upload }),
+                }, (upload) => exclusive(() => keepUpload(local, room.locator, head.id, upload)));
+            }
+            catch {
+                answered();
                 progress.complete = false;
-                progress.reachable = false;
-                return null;
+                if (continuing())
+                    progress.reachable = false;
+                return;
             }
-            if (closed) return null;
+            if (result.kind !== 'accepted' || !continuing())
+                answered();
+            if (!continuing())
+                return;
             if (result.kind === 'transport-uncertainty') {
                 progress.complete = false;
                 progress.reachable = false;
-                return null;
+                return;
             }
             if (result.kind === 'room-not-readable') {
                 progress.complete = false;
                 unreadable.add(room.locator);
                 list(room, false);
                 emitRooms();
-                return null;
+                return;
             }
             if (result.kind === 'revoked-authorization') {
-                refuse('revoked-authorization');
-                return 'stop';
+                await refuse('revoked-authorization');
+                return;
             }
             if (result.kind === 'scoped-refusal') {
                 await scoped(result, room, local);
                 progress.complete = false;
-                return null;
-            }
-            if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired' || result.kind === 'retryable-refusal') {
-                journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` + (result.kind === 'conflicted' && result.roomVersion !== undefined ? ` ${result.roomVersion}` : ''));
-                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);
-                    moveTo({
-                        ...status,
-                        ...attention()
-                    });
-                });
-                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';
+                return;
             }
-            if (pulled.kind === 'scoped-refusal') {
-                await scoped(pulled, room, local);
+            if (result.kind === 'write-halted') {
+                journal.record(`outcome ${room.locator} ${head.id} write-halted`);
+                await exclusive(() => mark(local, room.locator, head.id, { state: 'waiting' }, lost));
+                if (serviceMode === 'open' && openSignals !== opensBefore)
+                    continue;
+                haltedRefusal = true;
                 progress.complete = false;
-                return null;
+                return;
             }
-            if (pulled.kind === 'still-current') {
-                const committed = await exclusive(()=>commitAccept(room, local, head, result, from, true));
-                if (!committed) {
-                    progress.complete = false;
-                    return null;
+            if (result.kind === 'conflicted' ||
+                result.kind === 'rejected' ||
+                result.kind === 'expired' ||
+                result.kind === 'retryable-refusal') {
+                if (result.kind === 'expired') {
+                    const withheld = await advance(room, local, authorized);
+                    if (withheld !== null)
+                        return withhold(withheld, room, local, progress);
                 }
-                continue;
+                journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` +
+                    (result.kind === 'conflicted' && result.roomVersion !== undefined
+                        ? ` ${result.roomVersion}`
+                        : ''));
+                if (result.kind !== 'expired')
+                    journal.record(`refusal ${result.kind} ${result.code}`);
             }
-            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 (result.kind === 'retryable-refusal') {
+                const reset = result.reset;
+                progress.complete = false;
+                await exclusive(() => mark(local, room.locator, head.id, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
+                armTimer();
+                return;
             }
-            if (pulled.kind === 'beyond-horizon') {
-                const bootstrapped = await pullBootstrap(authorized, room);
-                if (bootstrapped.kind === 'revoked-authorization') {
-                    refuse('revoked-authorization');
-                    return 'stop';
-                }
-                if (bootstrapped.kind === 'scoped-refusal') {
-                    await scoped(bootstrapped, room, local);
-                    progress.complete = false;
-                    return null;
-                }
-                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;
+            if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
+                const left = leaving(head, result);
+                await exclusive(async () => {
+                    if (!continuing())
+                        return;
+                    const current = replicas.get(room.locator);
+                    if (current === undefined || !current.queue.some((batch) => batch.id === head.id)) {
+                        return;
                     }
+                    const set = await settle(local, room.locator, current, current.confirmed, current.queue.filter((batch) => batch.id !== head.id), {
+                        leaving: (result.kind === 'expired' && landed(head, current.confirmed)) ||
+                            (result.kind === 'conflicted' && landed(head, current.confirmed, result.affected))
+                            ? { ...left, returned: null }
+                            : left,
+                    });
+                    publishChangeSet(set);
+                    moveTo({ ...status, ...attention() });
+                });
+                if (result.kind === 'expired')
                     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;
+                const withheld = await advance(room, local, authorized);
+                if (withheld !== null)
+                    return withhold(withheld, room, local, progress);
+                continue;
             }
-            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();
+            const kept = await adopted(room, local, head, result).finally(answered);
+            if (!kept) {
+                progress.complete = false;
+                return;
             }
-            return null;
         }
-        return null;
+    }
+    function awaitingAnswer(locator) {
+        let release = () => { };
+        const awaited = new Promise((resolve) => {
+            release = resolve;
+        });
+        answering.set(locator, awaited);
+        return () => {
+            if (answering.get(locator) === awaited)
+                answering.delete(locator);
+            release();
+        };
     }
     async function retainModel(local, room, attached, next) {
         const key = modelKey(room.locator, attached);
-        if (next.status === 'unavailable') modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
-        const epoch = modelEpoch.get(key) ?? 0;
         const previous = modelOf(room.locator, attached);
         const heldBefore = replicas.get(room.locator)?.confirmed.record;
-        if (JSON.stringify(previous) === JSON.stringify(next) && (heldBefore === undefined || JSON.stringify(heldBefore.operations) === JSON.stringify(room.operations) && JSON.stringify(heldBefore.replica) === JSON.stringify(room.replica) && JSON.stringify(heldBefore.attachedModel) === JSON.stringify(room.attachedModel) && JSON.stringify(heldBefore.typedSelection) === JSON.stringify(room.typedSelection ?? null))) return;
-        const queryChanged = previous.status === 'unavailable' || next.status === 'unavailable' ? previous.status !== next.status : JSON.stringify(previous.types) !== JSON.stringify(next.types);
+        if (JSON.stringify(previous) === JSON.stringify(next) &&
+            (heldBefore === undefined ||
+                (JSON.stringify(heldBefore.operations) === JSON.stringify(room.operations) &&
+                    JSON.stringify(heldBefore.replica) === JSON.stringify(room.replica) &&
+                    JSON.stringify(heldBefore.typedSelection) ===
+                        JSON.stringify(room.typedSelection ?? null))))
+            return;
         if (next.status === 'unavailable') {
             invalidModels.add(key);
             liveModels.delete(key);
         }
-        await exclusive(async ()=>{
-            await hydrate(local);
-            if (next.status !== 'unavailable' && epoch !== (modelEpoch.get(key) ?? 0)) return;
+        await exclusive(async () => {
+            if (!continuing())
+                return;
             const held = replicas.get(room.locator);
             if (held !== undefined) {
-                const record = {
+                const declared = {
                     ...held.confirmed.record,
                     operations: room.operations,
                     replica: room.replica,
-                    attachedModel: room.attachedModel,
                     typedSelection: room.typedSelection ?? null,
-                    ...attached === 'collection' ? {
-                        model: next
-                    } : {
-                        selectionModel: next
-                    }
+                    ...(attached === 'collection' ? { model: next } : { selectionModel: next }),
                 };
-                await local.publish(record);
-                const confirmed = readConfirmed(record);
-                if (confirmed !== null) replicas.set(room.locator, replicaOf(confirmed, held.queue));
+                const reclassified = sameMembership(declared, held.confirmed.record)
+                    ? { kind: 'staged', confirmed: confirmedOf(declared, held.confirmed) }
+                    : readReclassified(declared, held.confirmed);
+                const record = reclassified.kind === 'staged'
+                    ? declared
+                    : {
+                        ...declared,
+                        typedSelection: held.confirmed.record.typedSelection,
+                    };
+                const read = reclassified.kind === 'deferred'
+                    ? { kind: 'staged', confirmed: confirmedOf(record, held.confirmed) }
+                    : reclassified;
+                await local.write({ next: record, previous: held.confirmed.record });
+                if (read.kind === 'staged') {
+                    replicas.set(room.locator, replicaOf(read.confirmed, held.queue, held));
+                    if (declarationRefusals.delete(room.locator)) {
+                        sourceRefusals.delete(room.locator);
+                        unreadable.delete(room.locator);
+                    }
+                }
+                else if (read.kind === 'refused') {
+                    replicas.set(room.locator, { ...held, confirmed: { ...held.confirmed, record } });
+                    refusedSource(room, read);
+                    declarationRefusals.add(room.locator);
+                }
             }
             models.set(key, next);
             if (next.status === 'current') {
@@ -1044,188 +1637,157 @@ export function createMdRuntime(options) {
                 invalidModels.delete(key);
             }
             list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
-            emitRooms();
-            if (queryChanged && held !== undefined) emitVisible();
-        });
-    }
-    async function acquireModel(local, room, authorized, selection) {
-        const attached = selection === null ? 'collection' : 'typed-selection';
-        const key = modelKey(room.locator, attached);
-        const declared = selection === null ? room.attachedModel : selection.attachedModel;
-        let previous = modelOf(room.locator, attached);
-        if (previous.status !== 'unavailable' && (declared === null || !sameModel(previous.snapshot, declared))) {
-            previous = {
-                status: 'unavailable',
-                reason: 'version-changed'
-            };
-            await retainModel(local, room, attached, previous);
-        }
-        const epoch = modelEpoch.get(key) ?? 0;
-        let answer;
-        try {
-            answer = await options.adapter.model(authorized, selection === null ? {
-                locator: room.locator,
-                attached: 'collection',
-                collectionRoot: room.collectionRoot,
-                model: declared
-            } : {
-                locator: room.locator,
-                attached: 'typed-selection',
-                roots: selection.roots,
-                model: declared
-            });
-        } catch  {
-            answer = {
-                kind: 'transport-uncertainty'
-            };
-        }
-        if (epoch !== (modelEpoch.get(key) ?? 0)) return;
-        if (answer.kind === 'revoked-authorization') {
-            await retainModel(local, room, attached, {
-                status: 'unavailable',
-                reason: 'revoked'
-            });
-            refuse('revoked-authorization');
-            return;
-        }
-        if (answer.kind === 'transport-uncertainty') {
-            await retainModel(local, room, attached, cached(previous));
-            return;
-        }
-        if (answer.kind === 'model-unavailable') {
-            await retainModel(local, room, attached, {
-                status: 'unavailable',
-                reason: answer.reason
-            });
-            return;
-        }
-        if (declared === null || !sameModel(answer.snapshot, declared)) {
-            await retainModel(local, room, attached, {
-                status: 'unavailable',
-                reason: 'version-changed'
-            });
-            return;
-        }
-        if (previous.status !== 'unavailable' && sameModel(previous.snapshot, answer.snapshot) && JSON.stringify(Object.entries(previous.snapshot.definitions).sort()) !== JSON.stringify(Object.entries(answer.snapshot.definitions).sort())) {
-            await retainModel(local, room, attached, {
-                status: 'unavailable',
-                reason: 'invalid'
-            });
-            return;
-        }
-        const verified = options.modelBinding?.verify(answer.snapshot);
-        await retainModel(local, room, attached, verified?.kind === 'verified' ? {
-            status: 'current',
-            snapshot: structuredClone(answer.snapshot),
-            verifiedWith: MD_MODEL,
-            types: verified.types
-        } : {
-            status: 'unavailable',
-            reason: verified === undefined ? 'binding-unavailable' : 'invalid'
+            if (held === undefined)
+                emitRooms();
+            else
+                publishChangeSet(changeSet(room.locator, held, replicas.get(room.locator) ?? null, { room: true }));
         });
     }
     async function scoped(result, room, local) {
         scopedRefusals.set(room.locator, {
             code: result.code,
-            fields: result.fields
+            fields: result.fields,
+            retryable: result.retryable,
         });
         let scopedAway = room;
-        if (result.scope === 'model') await retainModel(local, room, 'collection', {
-            status: 'unavailable',
-            reason: 'not-readable'
-        });
+        if (result.scope === 'model')
+            await retainModel(local, room, 'collection', {
+                status: 'unavailable',
+                reason: 'not-readable',
+            });
         else if (result.scope !== 'operation') {
             unreadable.add(room.locator);
             scopedAway = {
                 ...room,
-                replica: {
-                    ...room.replica,
-                    admission: 'unavailable'
-                },
+                replica: { ...room.replica, admission: 'unavailable' },
                 operations: {
                     ...room.operations,
-                    ...result.scope === 'content' ? {
-                        read: []
-                    } : {},
-                    ...result.scope === 'sync' ? {
-                        sync: []
-                    } : {}
-                }
+                    ...(result.scope === 'content' ? { read: [] } : {}),
+                    ...(result.scope === 'sync' ? { sync: [] } : {}),
+                },
             };
             await retainModel(local, scopedAway, 'collection', modelOf(room.locator));
         }
+        if (!continuing())
+            return;
         list(scopedAway, scopedAway.replica.admission === 'admitted' && !unreadable.has(room.locator));
         emitRooms();
         journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
     }
-    async function synchronize(discovered, local, progress) {
-        for (const room of discovered){
-            if (closed || authorization === undefined) {
-                progress.complete = false;
-                return;
-            }
-            const prior = replicas.get(room.locator)?.confirmed.record;
-            if (prior !== undefined && prior.replica.selection !== room.replica.selection) {
-                list(prior, false);
-                emitRooms();
-                journal.record(`selection changed ${room.locator}`);
-                progress.complete = false;
-                continue;
-            }
-            await acquireModel(local, room, authorization, null);
-            if (discoveryPaused) return;
-            if (room.typedSelection !== undefined) {
-                await acquireModel(local, room, authorization, room.typedSelection);
-                if (discoveryPaused) return;
-            }
-            if (room.replica.admission !== 'admitted') {
-                progress.complete = false;
-                continue;
-            }
-            const held = replicas.get(room.locator);
-            if (held !== undefined && held.confirmed.record.replica.selection !== room.replica.selection) {
-                progress.complete = false;
-                continue;
-            }
-            const withheld = await advance(room, local, authorization);
-            if (withheld !== null) {
+    function heldRooms(listed) {
+        return listed.flatMap((room) => {
+            const record = replicas.get(room.locator)?.confirmed.record;
+            if (record === undefined || record.replica.selection !== room.replica.selection)
+                return [];
+            return [
+                {
+                    locator: room.locator,
+                    roomVersion: record.roomVersion,
+                    documents: record.documents,
+                    revisions: record.revisions,
+                },
+            ];
+        });
+    }
+    async function synchronize(listed, local, progress, attempt) {
+        const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(room, local, progress)));
+        const ready = listed.filter((_, index) => {
+            const outcome = prepared[index];
+            return outcome?.status === 'fulfilled' && outcome.value;
+        });
+        if (attempt === 'opened') {
+            options.adapter.roomStream?.hold(heldRooms(ready));
+            handed = true;
+        }
+        const loaded = await Promise.allSettled(ready
+            .filter((room) => attempt === 'unstreamed' || !replicas.has(room.locator))
+            .map((room) => loadRoom(room, local, progress)));
+        const failed = [...prepared, ...loaded].find((room) => room.status === 'rejected');
+        if (failed !== undefined)
+            throw failed.reason;
+    }
+    async function prepareRoom(room, local, progress) {
+        if (closed || authorization === undefined) {
+            progress.complete = false;
+            return false;
+        }
+        const prior = replicas.get(room.locator)?.confirmed.record;
+        if (prior !== undefined && prior.replica.selection !== room.replica.selection) {
+            list(prior, false);
+            emitRooms();
+            journal.record(`selection changed ${room.locator}`);
+            progress.complete = false;
+            return false;
+        }
+        if (prior !== undefined)
+            await retainModel(local, room, 'collection', modelOf(room.locator));
+        if (discoveryPaused || authorization === undefined)
+            return false;
+        if (room.replica.admission !== 'admitted') {
+            if (replicas.has(room.locator))
                 progress.complete = false;
-                if (withheld.kind === 'scoped-refusal') {
-                    await scoped(withheld, room, local);
-                    continue;
-                }
-                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;
+            return false;
+        }
+        return true;
+    }
+    async function caughtUp(room, local, progress) {
+        const held = replicas.get(room.locator)?.confirmed.record.roomVersion;
+        if (held === undefined || authorization === undefined)
+            return;
+        const behind = [announced.get(room.locator), room.roomVersion].some((later) => later !== undefined && !options.adapter.reached(room.locator, held, later));
+        if (!behind)
+            return;
+        const withheld = await advance(room, local, authorization);
+        if (withheld !== null)
+            await withhold(withheld, room, local, progress);
+    }
+    function revoked(locator) {
+        return ['collection', 'typed-selection'].some((attached) => {
+            const model = modelOf(locator, attached);
+            return model.status === 'unavailable' && model.reason === 'revoked';
+        });
+    }
+    async function loadRoom(room, local, progress) {
+        if (discoveryPaused || authorization === undefined)
+            return;
+        if (replicas.has(room.locator) && revoked(room.locator)) {
+            await reload(room, local, progress);
+            return;
+        }
+        const withheld = await advance(room, local, authorization);
+        if (withheld !== null) {
+            await withhold(withheld, room, local, progress);
+            return;
         }
+        await caughtUp(room, local, progress);
     }
-    async function cycle(local, progress) {
+    async function reload(room, local, progress) {
+        if (discoveryPaused || authorization === undefined)
+            return;
+        const bootstrapped = await pullBootstrap(authorization, room, local);
+        if (!continuing())
+            return;
+        if (bootstrapped.kind !== 'staged') {
+            await withhold(bootstrapped, room, local, progress);
+            return;
+        }
+        await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored });
+        await caughtUp(room, local, progress);
+    }
+    async function discoverRooms(local, progress, attempt) {
         if (closed || authorization === undefined) {
             notifyReady();
             return;
         }
         moveTo(transferring(status));
+        discoveries += 1;
+        const started = discoveries;
         let result;
         try {
             result = await options.adapter.discover(authorization);
-        } catch  {
-            result = {
-                kind: 'transport-uncertainty'
-            };
+        }
+        catch {
+            result = { kind: 'transport-uncertainty' };
         }
         if (closed) {
             notifyReady();
@@ -1233,78 +1795,48 @@ export function createMdRuntime(options) {
         }
         journal.record(`connection discover ${result.kind}`);
         if (result.kind === 'transport-uncertainty') {
-            for (const room of rooms.values()){
+            for (const room of rooms.values()) {
                 await retainModel(local, room, 'collection', cached(modelOf(room.locator)));
                 if (room.typedSelection !== null) {
                     await retainModel(local, room, 'typed-selection', cached(modelOf(room.locator, 'typed-selection')));
                 }
             }
             progress.reachable = false;
+            progress.complete = false;
             notifyReady();
             return;
         }
         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
+                fields: result.fields,
+                retryable: result.retryable,
             });
             notifyReady();
             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');
-            notifyReady();
-            return;
-        }
-        if (result.mdModel.identity !== MD_MODEL.identity || result.mdModel.version !== MD_MODEL.version) {
-            refuse('md-model-version-mismatch');
-            notifyReady();
-            return;
-        }
-        mismatchedRoots.clear();
-        for (const room of result.rooms){
-            const held = replicas.get(room.locator)?.confirmed.record;
-            const malformed = !validRoot(room.collectionRoot);
-            if (room.operations === undefined || ![
-                'read',
-                'sync',
-                'write',
-                'delete'
-            ].every((operation)=>Array.isArray(room.operations[operation]) && room.operations[operation].every((scope)=>typeof scope === 'string')) || room.replica === undefined || typeof room.replica.selection !== 'string' || room.replica.selection.length === 0 || ![
-                'admitted',
-                'unavailable'
-            ].includes(room.replica.admission) || !declaredIdentity(room.attachedModel)) {
+        for (const room of result.rooms) {
+            if (room.operations === undefined ||
+                !['read', 'sync', 'write', 'delete'].every((operation) => Array.isArray(room.operations[operation]) &&
+                    room.operations[operation].every((scope) => typeof scope === 'string')) ||
+                room.replica === undefined ||
+                typeof room.replica.selection !== 'string' ||
+                room.replica.selection.length === 0 ||
+                !['admitted', 'unavailable'].includes(room.replica.admission)) {
                 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');
-                notifyReady();
-                return;
-            }
-            if (malformed || held !== undefined && held.collectionRoot !== room.collectionRoot) {
-                mismatchedRoots.add(room.locator);
-                journal.record(`collection root ${malformed ? 'invalid' : 'changed'} ${room.locator}`);
-            }
-        }
-        if (mismatchedRoots.size > 0) {
-            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;
             }
@@ -1313,392 +1845,651 @@ export function createMdRuntime(options) {
             refusal = null;
             emitRefusal();
         }
+        const previousCapabilities = capabilities;
         capabilities = result.capabilities;
         notifyReady();
-        if (declared.has('room-version-notifications')) observeRoomVersions();
-        if (declared.has('provider-actions')) observeConversations();
-        if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits)) {
+        if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits) ||
+            JSON.stringify(result.capabilities) !== JSON.stringify(previousCapabilities)) {
             limits = result.providerLimits;
-            await local.declare(limits);
+            await local.declare(limits, capabilities);
+        }
+        const signedIn = result.member ?? null;
+        if (JSON.stringify(signedIn) !== JSON.stringify(member)) {
+            await local.keepMember(signedIn);
+            member = signedIn;
+            emitMember();
         }
-        const listedLocators = applyDiscovery(result.rooms);
-        handSelected(result.rooms.filter((room)=>room.replica.admission === 'admitted').map((room)=>room.locator).sort());
-        progress.complete = [
-            ...replicas.keys()
-        ].every((locator)=>listedLocators.has(locator));
-        await synchronize(result.rooms, local, progress);
+        await synchronize(await applyDiscovery(result.rooms, started), local, progress, attempt);
     }
     async function ensureAuthorization() {
-        if (authorization !== undefined) return;
+        if (authorization !== undefined)
+            return;
         try {
             authorization = await options.adapter.authorize();
             journal.record('connection authorize');
-        } catch (error) {
+        }
+        catch (error) {
             journal.record('connection authorize transport-uncertainty');
             throw error;
         }
     }
-    async function connect() {
-        if (closed || discoveryPaused) {
-            notifyReady();
+    function task(work) {
+        if (stopping)
+            return chain;
+        chain = chain.then(work, work).catch(() => undefined);
+        return chain;
+    }
+    function sync(attempt) {
+        return task(async () => {
+            if (closed || stopping || discoveryPaused) {
+                notifyReady();
+                return;
+            }
+            const progress = { complete: true, reachable: true };
+            underway = attempt === 'opened' ? progress : null;
+            if (attempt === 'opened')
+                streamed = progress;
+            complete = false;
+            recorded = false;
+            moveTo(transferring(status));
+            handed = false;
+            try {
+                const local = await openLocal();
+                if (closed)
+                    return;
+                await ensureAuthorization();
+                if (closed)
+                    return;
+                await discoverRooms(local, progress, attempt);
+            }
+            catch {
+                progress.complete = false;
+                if (attempt === 'opened' && !handed)
+                    progress.reachable = false;
+            }
+            finally {
+                notifyReady();
+            }
+            if (attempt !== 'opened') {
+                await finishOpening(progress);
+                return;
+            }
+            if (handed || closed || progress.reachable)
+                return;
+            underway = null;
+            journal.record('connection reopen');
+            await rest(progress);
+            options.adapter.roomStream?.reopen();
+        });
+    }
+    function closedSocket(revoked) {
+        const opened = socketOpen;
+        socketOpen = false;
+        if (revoked) {
+            void refuse('revoked-authorization');
             return;
         }
-        startTimer();
-        const progress = {
-            complete: false,
-            reachable: true
-        };
-        let completedAt = new Date().toISOString();
+        complete = false;
+        if (streamed !== null)
+            streamed.complete = false;
+        moveTo({
+            ...status,
+            state: status.state === 'synced' ? 'syncing' : status.state,
+            providerUnreachable: status.providerUnreachable || !opened,
+        });
+    }
+    function applyOpening(expired) {
+        return task(async () => {
+            const progress = underway;
+            underway = null;
+            if (closed || stopping)
+                return;
+            if (progress === null) {
+                await reloadExpired(expired);
+                return;
+            }
+            try {
+                const local = await openLocal();
+                const held = [...discovered.values()].filter((room) => replicas.has(room.locator));
+                const reloading = held.filter((room) => expired.includes(room.locator) || revoked(room.locator));
+                const reloaded = await Promise.allSettled(reloading.map((room) => reload(room, local, progress)));
+                if (progress.reachable) {
+                    for (const room of held)
+                        if (!reloading.includes(room))
+                            await confirmModels(room, local);
+                }
+                const failed = reloaded.find((outcome) => outcome.status === 'rejected');
+                if (failed !== undefined)
+                    throw failed.reason;
+            }
+            catch {
+                progress.complete = false;
+                progress.reachable = false;
+            }
+            await finishOpening(progress);
+        });
+    }
+    async function reloadExpired(expired) {
+        const progress = { complete: true, reachable: true };
         try {
             const local = await openLocal();
-            if (closed) return;
-            await ensureAuthorization();
-            if (closed) return;
-            await cycle(local, progress);
-            if (closed) return;
-            if (progress.complete) {
-                completedAt = new Date().toISOString();
-                await local.complete(completedAt);
+            await Promise.allSettled([...discovered.values()]
+                .filter((room) => replicas.has(room.locator) && expired.includes(room.locator))
+                .map((room) => reload(room, local, progress)));
+        }
+        catch {
+            progress.reachable = false;
+        }
+        await rest(progress);
+    }
+    async function confirmModels(room, local) {
+        for (const attached of ['collection', 'typed-selection']) {
+            const model = modelOf(room.locator, attached);
+            if (model.status === 'cached') {
+                await retainModel(local, room, attached, { ...model, status: 'current' });
             }
-        } catch  {
-            progress.complete = false;
-            notifyReady();
+        }
+    }
+    function submitLater(locator) {
+        if (localSaves)
+            return;
+        const running = submitting.get(locator);
+        if (running !== undefined) {
+            running.again = true;
             return;
-        } finally{
-            notifyReady();
-            moveTo(settled(status, progress, completedAt, pending(), attention()));
         }
+        const run = { again: false, done: Promise.resolve() };
+        submitting.set(locator, run);
+        run.done = (async () => {
+            try {
+                do {
+                    run.again = false;
+                    const room = discovered.get(locator);
+                    if (closed || stopping || discoveryPaused || room === undefined)
+                        return;
+                    const progress = { complete: true, reachable: true };
+                    try {
+                        await ensureAuthorization();
+                        if (authorization === undefined)
+                            return;
+                        await submitRoom(room, await openLocal(), authorization, progress);
+                    }
+                    catch {
+                        progress.reachable = false;
+                    }
+                    armTimer();
+                    await rest(progress);
+                } while (run.again);
+            }
+            finally {
+                submitting.delete(locator);
+            }
+        })();
     }
-    async function run() {
+    function submitAll() {
+        for (const [locator, replica] of replicas) {
+            if (replica.queue.length > 0)
+                submitLater(locator);
+        }
+    }
+    async function finishOpening(progress) {
         try {
-            await connect();
-        } finally{
-            inflight = false;
-            if (queued && !closed) {
-                queued = false;
-                void enqueue();
+            if (closed || discoveryPaused) {
+                progress.complete = false;
+                return;
+            }
+            submitAll();
+            await conversations.reconcile();
+            if (status.providerUnreachable)
+                conversations.reconnected();
+            const reading = { complete: true, reachable: true };
+            await conversations.catchUp(reading);
+            if (!reading.reachable)
+                progress.reachable = false;
+        }
+        catch {
+            progress.complete = false;
+        }
+        finally {
+            complete = progress.complete;
+            await rest(progress);
+        }
+    }
+    async function rest(progress) {
+        if (closed)
+            return;
+        let lastCompleted = status.lastCompleted;
+        let synced = complete && stale.size === 0 && !pending();
+        if (synced && !recorded) {
+            const completedAt = new Date().toISOString();
+            try {
+                await (await openLocal()).complete(completedAt);
+                recorded = true;
+                lastCompleted = completedAt;
+            }
+            catch {
+                synced = false;
             }
         }
+        moveTo({
+            state: pending() ? 'pending' : synced && complete ? 'synced' : 'syncing',
+            lastCompleted,
+            providerUnreachable: !progress.reachable,
+            ...attention(),
+        });
     }
-    function observeRoomVersions() {
-        const path = options.adapter.roomVersions;
-        if (path === undefined || withdrawNotifications !== undefined) return;
-        withdrawNotifications = path.observe((notification)=>{
-            if (closed || discoveryPaused) return;
-            notices.set(notification.locator, notification.roomVersion);
-            chain = chain.then(runNotified, runNotified);
+    function applyRoom(locator, roomVersion) {
+        announced.set(locator, roomVersion);
+        return task(async () => {
+            await answering.get(locator);
+            if (closed || stopping || discoveryPaused || authorization === undefined)
+                return;
+            const room = discovered.get(locator);
+            const held = replicas.get(locator);
+            if (room === undefined || room.replica.admission !== 'admitted')
+                return;
+            if (held !== undefined &&
+                (held.confirmed.record.replica.selection !== room.replica.selection ||
+                    options.adapter.reached(locator, held.confirmed.record.roomVersion, roomVersion))) {
+                return;
+            }
+            const during = underway;
+            const progress = during ?? { complete: true, reachable: true };
+            if (during === null)
+                moveTo(transferring(status));
+            try {
+                const local = await openLocal();
+                const withheld = await advance(room, local, authorization);
+                if (withheld !== null)
+                    await withhold(withheld, room, local, progress);
+            }
+            catch {
+                stale.add(locator);
+            }
+            finally {
+                if (during === null)
+                    await rest(progress);
+            }
         });
     }
+    function observeStream() {
+        const stream = options.adapter.roomStream;
+        if (stream === undefined || withdrawStream !== undefined)
+            return;
+        withdrawStream = stream.observe((event) => {
+            if (closed || stopping)
+                return;
+            if (event.kind === 'opened') {
+                socketOpen = true;
+                void sync('opened');
+            }
+            else if (event.kind === 'closed')
+                closedSocket(event.revoked);
+            else if (event.kind === 'opening')
+                void applyOpening(event.expired);
+            else
+                void applyRoom(event.locator, event.roomVersion);
+        });
+    }
+    function writesHeld() {
+        return serviceMode === 'write-halted' || haltedRefusal;
+    }
+    function signalled(mode) {
+        if (closed)
+            return;
+        if (mode === 'open')
+            openSignals += 1;
+        const releasing = mode === 'open' && (haltedRefusal || serviceMode === 'write-halted');
+        if (mode === 'open')
+            haltedRefusal = false;
+        if (mode !== serviceMode) {
+            serviceMode = mode;
+            journal.record(`service mode ${mode}`);
+            for (const listener of serviceModeListeners)
+                listener(mode);
+        }
+        if (releasing)
+            submitAll();
+    }
     function observeConversations() {
-        const path = options.adapter.conversations;
-        if (path === undefined || withdrawConversations !== undefined) return;
-        withdrawConversations = path.observe((event)=>{
-            conversations.receive(event);
+        const stream = options.adapter.conversations;
+        if (stream === undefined || withdrawConversations !== undefined)
+            return;
+        withdrawConversations = stream.observe((event) => {
+            if (conversations.receive(event)) {
+                void ready.then(scheduleCurrency);
+                return;
+            }
+            if (event.kind !== 'gap' || conversations.current())
+                return;
+            show();
+            scheduleCurrency();
         });
     }
-    function handSelected(locators) {
-        const path = options.adapter.roomVersions;
-        if (path === undefined || withdrawNotifications === undefined) return;
-        if (handed !== undefined && JSON.stringify(locators) === JSON.stringify(handed)) return;
-        handed = locators;
-        path.select(locators);
+    function scheduleCurrency() {
+        if (currencyQueued || closed || stopping)
+            return;
+        currencyQueued = true;
+        void task(runCurrency);
     }
-    async function runNotified() {
-        const announced = [
-            ...notices
-        ];
-        notices.clear();
-        if (announced.length === 0 || closed || discoveryPaused) return;
-        const resting = status;
-        const progress = {
-            complete: false,
-            reachable: !resting.providerUnreachable
-        };
-        moveTo(transferring(resting));
+    async function runCurrency() {
+        currencyQueued = false;
+        if (closed || stopping || discoveryPaused)
+            return;
+        await conversations.reconcile();
+        if (conversations.current()) {
+            show();
+            return;
+        }
+        const progress = { complete: false, reachable: !status.providerUnreachable };
+        moveTo(transferring(status));
         try {
-            const local = await openLocal();
-            for (const [locator, roomVersion] of announced){
-                if (closed || discoveryPaused || authorization === undefined) return;
-                if (handed?.includes(locator) !== true) continue;
-                const room = discovered.get(locator);
-                const held = replicas.get(locator);
-                if (room === undefined || held === undefined) continue;
-                if (held.confirmed.record.roomVersion === roomVersion) continue;
-                const withheld = await advance(room, local, authorization);
-                if (withheld === null) continue;
-                if (withheld.kind === 'scoped-refusal') {
-                    await scoped(withheld, room, local);
-                    continue;
-                }
-                if (withheld.kind === 'transport-uncertainty') {
-                    progress.reachable = false;
-                    continue;
-                }
-                if (withheld.kind === 'room-not-readable') {
-                    unreadable.add(locator);
-                    list(room, false);
-                    emitRooms();
-                    continue;
-                }
-                if (withheld.kind === 'revoked-authorization') {
-                    refuse('revoked-authorization');
-                    return;
-                }
-            }
-        } catch  {
-            progress.reachable = false;
-        } finally{
-            if (!closed) {
-                moveTo(settled(resting, progress, resting.lastCompleted, pending(), attention()));
-            }
+            await conversations.catchUp(progress);
         }
-    }
-    function enqueue() {
-        if (inflight) {
-            queued = true;
-            return chain;
+        catch {
+            progress.reachable = false;
         }
-        inflight = true;
-        chain = chain.then(run, run);
-        return chain;
+        await rest(progress);
     }
     function close() {
+        if (closed)
+            return;
         closed = true;
-        withdrawNotifications?.();
-        withdrawNotifications = undefined;
+        withdrawStream?.();
+        withdrawStream = undefined;
         withdrawConversations?.();
         withdrawConversations = undefined;
+        withdrawServiceMode?.();
         conversations.close();
         stopTimer();
         store?.close();
-        void opening?.then((opened)=>{
+        void opening?.then((opened) => {
             opened.close();
-        }, ()=>{});
+        }, () => { });
         roomListeners.clear();
         refusalListeners.clear();
         storageLossListeners.clear();
         statusListeners.clear();
-        querySubscriptions.clear();
+        serviceModeListeners.clear();
+        memberListeners.clear();
+        readSide.close();
         queueSubscriptions.clear();
-        draftListeners.clear();
+        roomDraftListeners.clear();
         presentationListeners.clear();
     }
-    options.signal?.addEventListener('abort', close, {
-        once: true
-    });
-    if (options.signal?.aborted) close();
-    void openLocal().catch(()=>{
+    async function stop() {
+        stopping = true;
+        stopTimer();
+        await chain.catch(() => undefined);
+        await Promise.all([...submitting.values()].map((run) => run.done));
+        await mutations;
+        close();
+    }
+    const withdrawServiceMode = options.adapter.serviceMode?.observe(signalled);
+    observeConversations();
+    options.signal?.addEventListener('abort', close, { once: true });
+    if (options.signal?.aborted)
+        close();
+    observeStream();
+    void openLocal().then(() => {
+        if (capabilities.length > 0)
+            notifyReady();
+    }, () => {
         notifyReady();
     });
-    void enqueue();
-    return {
-        rooms () {
-            return listed();
+    if (options.adapter.roomStream === undefined)
+        void sync('unstreamed');
+    function planned(input, reach) {
+        return planOf(input, roomFacts(reach), planReach(reach));
+    }
+    function watchPlan(plan, deliver) {
+        materialize(reachedRooms(plan));
+        return readSide.watch(plan, identityOf(plan), deliver);
+    }
+    async function searched(input, reach) {
+        const plan = searchPlanOf(input);
+        const selected = plan.documents === undefined && reach === null
+            ? null
+            : (await rowsQuery(filterOf(plan.documents ?? {}, roomFacts(reach), planReach(reach)))).documents;
+        if (selected === null)
+            materialize(null);
+        return searchIndex.search(reach === null || reach.conversations ? plan : { ...plan, conversations: [] }, selected);
+    }
+    const watch = (topic, input, deliver) => {
+        if (topic === 'room-drafts') {
+            const listener = { notify: deliver, ready: false };
+            roomDraftListeners.add(listener);
+            void exclusive(async () => {
+                await openLocal();
+                if (closed || !roomDraftListeners.has(listener))
+                    return;
+                listener.ready = true;
+            }).then(() => {
+                if (closed || !listener.ready || !roomDraftListeners.has(listener))
+                    return;
+                listener.notify(snapshotRoomDrafts());
+            }, () => { });
+            return () => {
+                roomDraftListeners.delete(listener);
+            };
+        }
+        if (topic === 'conversation') {
+            return conversations.watch(input[0], input[1], deliver);
+        }
+        if (topic === 'conversations')
+            return conversations.watchList(deliver);
+        if (topic === 'agents')
+            return conversations.watchAgents(deliver);
+        if (topic === 'presentation') {
+            const listener = {
+                app: input[0],
+                notify: deliver,
+                ready: false,
+            };
+            presentationListeners.add(listener);
+            void exclusive(async () => {
+                await openLocal();
+            }).then(() => {
+                if (closed || !presentationListeners.has(listener))
+                    return;
+                listener.ready = true;
+                listener.notify(presentationOf(listener.app));
+            }, () => { });
+            return () => {
+                presentationListeners.delete(listener);
+            };
+        }
+        if (topic === 'rooms') {
+            roomListeners.add(deliver);
+            deliver(listed());
+            return () => {
+                roomListeners.delete(deliver);
+            };
+        }
+        if (topic === 'connection-refusal') {
+            refusalListeners.add(deliver);
+            deliver(refusal);
+            return () => {
+                refusalListeners.delete(deliver);
+            };
+        }
+        if (topic === 'storage-loss') {
+            storageLossListeners.add(deliver);
+            deliver(storageLoss);
+            return () => {
+                storageLossListeners.delete(deliver);
+            };
+        }
+        if (topic === 'sync-status') {
+            statusListeners.add(deliver);
+            deliver(shown);
+            return () => {
+                statusListeners.delete(deliver);
+            };
+        }
+        if (topic === 'service-mode') {
+            serviceModeListeners.add(deliver);
+            deliver(serviceMode);
+            return () => {
+                serviceModeListeners.delete(deliver);
+            };
+        }
+        if (topic === 'member') {
+            memberListeners.add(deliver);
+            deliver(member);
+            return () => {
+                memberListeners.delete(deliver);
+            };
+        }
+        if (topic === 'queue') {
+            const queue = { locator: input[0], notify: deliver };
+            queueSubscriptions.add(queue);
+            queue.notify(entriesOf(queue.locator));
+            return () => {
+                queueSubscriptions.delete(queue);
+            };
+        }
+        return watchPlan(planned(input[0], null), deliver);
+    };
+    const md = {
+        loaded() {
+            return openLocal().then(() => undefined);
         },
-        query (request = {}) {
-            return visible(request);
+        rooms() {
+            return listed();
         },
-        types (locator) {
+        query: ((input) => rowsQuery(planned(input, null))),
+        search: (input) => searched(input, null),
+        types(locator) {
             return {
                 collection: modelTypes(modelOf(locator)),
-                typedSelection: rooms.get(locator)?.typedSelection === undefined || rooms.get(locator)?.typedSelection === null ? null : modelTypes(modelOf(locator, 'typed-selection'))
+                typedSelection: rooms.get(locator)?.typedSelection === undefined ||
+                    rooms.get(locator)?.typedSelection === null
+                    ? null
+                    : modelTypes(modelOf(locator, 'typed-selection')),
             };
         },
-        syncStatus () {
-            return status;
-        },
-        draft: {
-            list () {
-                return exclusive(async ()=>{
-                    const local = await openLocal();
-                    return readDrafts(local);
-                }).then((entries)=>{
-                    releaseWaitingDrafts();
-                    return entries;
+        roomDraft: {
+            list() {
+                return exclusive(async () => {
+                    await openLocal();
+                    return snapshotRoomDrafts();
+                }).then((listed) => {
+                    publishRoomDrafts(true);
+                    return listed;
                 });
             },
-            read (locator, path) {
-                const content = draftContent(locator, path);
-                return content === undefined ? null : structuredClone(content);
+            read(room, path) {
+                const record = roomDrafts.get(room)?.get(path);
+                return record === undefined ? null : roomDraftOf(record);
             },
-            replace (locator, path, content) {
-                return commitDraft(async (local)=>{
-                    const stored = structuredClone(content);
-                    await local.keep({
-                        locator,
+            write(room, path, revision, input) {
+                return exclusive(async () => {
+                    const parts = readParts(input);
+                    if (path === '' || normalize(path) !== path)
+                        throw runtimeError('room-draft-malformed');
+                    const local = await openLocal();
+                    const current = roomDrafts.get(room)?.get(path);
+                    if ((current?.revision ?? null) !== revision) {
+                        return staleWrite(current === undefined ? null : roomDraftOf(current));
+                    }
+                    const file = parts.file === undefined
+                        ? undefined
+                        : await heldFile(parts.file.blob, binaryBase(replicas.get(room)?.visible, path));
+                    const record = {
+                        locator: room,
                         path,
-                        content: stored
-                    });
-                    rememberDraft(locator, path, stored);
+                        revision: roomDraftRevision(),
+                        parts: held(current?.parts, parts, file),
+                        returned: current?.returned ?? null,
+                    };
+                    await local.keepRoomDraft(record);
+                    rememberRoomDraft(record);
+                    publishChangeSet(changeSet(room, null, null, { drafts: [path] }));
+                    return { outcome: 'written', roomDraft: roomDraftOf(record) };
                 });
             },
-            discard (locator, path) {
-                return commitDraft(async (local)=>{
-                    await local.discard(locator, path);
-                    forgetDraft(locator, path);
+            discard(room, path, revision) {
+                return exclusive(async () => {
+                    const local = await openLocal();
+                    const current = roomDrafts.get(room)?.get(path);
+                    if (current === undefined || current.revision !== revision) {
+                        return staleWrite(current === undefined ? null : roomDraftOf(current));
+                    }
+                    await local.discardRoomDraft(room, path);
+                    forgetRoomDraft(room, path);
+                    publishChangeSet(changeSet(room, null, null, { drafts: [path] }));
+                    moveTo({ ...status, ...attention() });
+                    return { outcome: 'written', roomDraft: null };
                 });
-            }
+            },
         },
         conversation: conversations.surface,
+        chatDraft: conversations.chatDraft,
         presentation: {
-            read (app) {
-                return exclusive(async ()=>{
-                    await hydrate(await openLocal());
+            read(app) {
+                return exclusive(async () => {
+                    await openLocal();
                     return presentationOf(app);
                 });
             },
-            write (app, value) {
-                return exclusive(async ()=>{
+            write(app, value) {
+                return exclusive(async () => {
                     const local = await openLocal();
-                    await hydrate(local);
                     const stored = structuredClone(value);
-                    await local.present({
-                        app,
-                        value: stored
-                    });
+                    await local.present({ app, value: stored });
                     presentations.set(app, stored);
-                }).then(()=>{
-                    emitPresentation(app);
+                    publishChangeSet(changeSet('', null, null, { presentation: app }));
                 });
-            }
-        },
-        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));
-            }
+        save(room, named, writtenBy) {
+            return exclusive(() => saveRoomDrafts(room, named, writtenBy));
         },
-        history (locator, path, query) {
+        history(locator, path, query) {
             return readHistory(locator, path, query);
         },
-        call (name, input) {
+        binaryFile: {
+            read: readBinaryPath,
+            readReference: readBinaryReference,
+        },
+        call(name, input) {
             return invokeAction(name, input);
         },
-        log () {
-            return journal.export();
+        reached(locator, roomVersion, path) {
+            return path === undefined
+                ? reachedBy(locator, roomVersion)
+                : writtenAfter(locator, roomVersion, path);
         },
-        storageLoss () {
-            return storageLoss;
+        log() {
+            return journal.export();
         },
-        persistence () {
+        persistence() {
             return options.shell.persistentStorage;
         },
-        observe (topic, second, third) {
-            if (topic === 'drafts') {
-                const notify = second;
-                const listener = {
-                    notify,
-                    ready: false
-                };
-                draftListeners.add(listener);
-                void exclusive(async ()=>{
-                    const local = await openLocal();
-                    await readDrafts(local);
-                    if (closed || !draftListeners.has(listener)) return;
-                    listener.ready = true;
-                }).then(()=>{
-                    if (closed || !listener.ready || !draftListeners.has(listener)) return;
-                    listener.notify(snapshotDrafts());
-                }, ()=>{});
-                return ()=>{
-                    draftListeners.delete(listener);
-                };
-            }
-            if (topic === 'conversation') {
-                return conversations.observe(second, third);
-            }
-            if (topic === 'presentation') {
-                const listener = {
-                    app: second,
-                    notify: third,
-                    ready: false
-                };
-                presentationListeners.add(listener);
-                void exclusive(async ()=>{
-                    await hydrate(await openLocal());
-                }).then(()=>{
-                    if (closed || !presentationListeners.has(listener)) return;
-                    listener.ready = true;
-                    listener.notify(presentationOf(listener.app));
-                }, ()=>{});
-                return ()=>{
-                    presentationListeners.delete(listener);
-                };
-            }
-            if (topic === 'rooms') {
-                const notify = second;
-                roomListeners.add(notify);
-                notify(listed());
-                return ()=>{
-                    roomListeners.delete(notify);
-                };
-            }
-            if (topic === 'connection-refusal') {
-                const notify = second;
-                refusalListeners.add(notify);
-                notify(refusal);
-                return ()=>{
-                    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);
-                notify(status);
-                return ()=>{
-                    statusListeners.delete(notify);
-                };
-            }
-            if (topic === 'queue') {
-                const queue = {
-                    locator: second,
-                    notify: third
-                };
-                queueSubscriptions.add(queue);
-                queue.notify(entriesOf(queue.locator));
-                return ()=>{
-                    queueSubscriptions.delete(queue);
-                };
-            }
-            const subscription = {
-                query: second,
-                notify: third
-            };
-            const first = visible(subscription.query);
-            querySubscriptions.add(subscription);
-            subscription.notify(first);
-            return ()=>{
-                querySubscriptions.delete(subscription);
-            };
-        },
-        async reauthorize () {
-            if (refusal === null || !refusal.reauthorizationOffered) return;
+        observe: observing(watch),
+        async reauthorize() {
+            if (refusal === null || !refusal.reauthorizationOffered)
+                return;
             journal.record('connection reauthorize');
+            await chain.catch(() => undefined);
+            await mutations;
             authorization = undefined;
             discoveryPaused = false;
-            await enqueue();
-        }
+            if (options.adapter.roomStream === undefined)
+                await sync('unstreamed');
+            else
+                await task(ensureAuthorization);
+        },
+    };
+    const reachable = {
+        md,
+        watch,
+        referrerScope: (referrer) => options.adapter.referrerScope(referrer),
+        plan: planned,
+        query: (plan) => rowsQuery(plan),
+        watchPlan,
+        search: searched,
     };
+    return { md, stop, lose: loseRooms, watch, within: (reach) => narrowed(reachable, reach) };
 }
-
-//# sourceMappingURL=connection.js.map