@agentshouse/mdruntime 0.1.0-ce531b51ff088 → 0.1.0-ce6bc9239a3ee

package/dist/connection.js

@@ -1,244 +1,491 @@
-import { verify } from '@agentshouse/mdmodel';
-import { cached, modelTypes, NO_MODEL, sameModel, } from './model.js';
-import { opened } from './observation.js';
-import { filterOf, identityOf, planOf, } from './query.js';
-import { createReadSide } from './read-side.js';
-import { createSearchIndex, searchPlanOf, } from './search.js';
-import { ROOM_CONTRACT_VERSION, VERSION_1_CAPABILITIES, } from './adapter.js';
-import { bootstrapRoom } from './bootstrap.js';
+import { identityOf, roomTarget, target, } from '@agentshouse/mdmodel';
+import { builtInModel, roomTypesOf } from './attached-model.js';
+import { modelTypes, NO_MODEL } from './model.js';
+import { observing } from './observation.js';
+import { planWithin, } from './query.js';
+import { createFigures, ROOM_TOTALS } from './figures.js';
+import { createLiveQueries } from './live.js';
+import { keepEntrySeed, seedApplies, seededResult, watchSeeded, } from './seed.js';
+import { documentKey, roomOfKey } from './rows.js';
+import { searchPlanOf } from './search.js';
+import { capped, MAXIMUM_WINDOW } from './windows.js';
+import { behind, catching, caughtUpTo, forgetInstall, installationOf, publish, pullBootstrap, pullRefresh, reachedBy, replaced, roomInFlight, standingAt, writtenAfter, } from './install.js';
 import { changeSet, mergeChangeSets } from './change-set.js';
 import { createConversationStore, } from './conversation.js';
-import { MD_MODEL, parseCollection, validRoot } from './collection.js';
+import { composedOf, validRoot } from './collection.js';
 import { createLog } from './log.js';
-import { refreshRoom } from './refresh.js';
-import { buildBatch } from './save.js';
-import { applyReturned, compositionOf, landed, readConfirmed, readReclassified, replicaOf, sameMembership, withdrawals, } from './replica.js';
-import { changedParts, changesOf, held, readParts, returnedInto, underneath, } from './room-draft.js';
-import { settled, same, saving, STARTING, transferring, } from './status.js';
-import { detectStorageLoss, nextGeneration } from './durability.js';
-import { roomDraftRevision } from './identity.js';
-import { beneath, normalize } from './paths.js';
-import { openRuntimeStore, } from './store.js';
+import { ABSENT_TARGET, calledResult, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, OFFLINE, undeclared, UNCERTAIN, UNREADABLE, } from './outcome.js';
+import { readAnswers } from './reads.js';
+import { createRecovery } from './recovery.js';
+import { storedRecord } from './replica.js';
+import { same, STARTING, } from './status.js';
+import { detectStorageLoss, nextGeneration, refusedForSpace, } from './durability.js';
+import { readinessOf, } from './readiness.js';
+import { yielded } from './turn.js';
+import { beneath } from './paths.js';
+import { createStore, } from './store.js';
+import { emitPresentation, presentationSurface, publishRoomDrafts, roomDraftSurface, watchPresentation, watchRoomDrafts, } from './room-drafts.js';
+import { createSocket } from './socket.js';
 import { unconfirmed } from './transfer.js';
-// Discovery repeats each minute so a Room the stream stopped serving stays unrefreshed no longer.
-const DEFAULT_DISCOVERY_INTERVAL_MS = 60_000;
-const EMPTY_SCHEMA = { verdict: 'accept', model: { types: {} } };
-const knownCapabilities = new Set(VERSION_1_CAPABILITIES);
+import { governs, holds, narrowed, planReach, } from './reach.js';
+import { binaryFileSurface, overlayDiff, preparedAfter, replayed, saveParts, saveRoomDrafts, settle, sliceAt, } from './saves.js';
+import { submitAll, submitLater, unpair } from './acceptance.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 !== '' &&
         selection.roots.every((other, at) => at === index || !within(other, root)));
 }
+const OPENING_LANE = 'opening';
+const CONVERSATION_LANE = 'conversations';
+const ROOM_READS = 256;
+const ROOM_ATTEMPTS = 16;
+const ERASE_BATCH = 512;
+const QUERY_BYTES = 1 << 20;
+// A Room the Provider answers not ready is asked again after these waits, the last repeating, so a chunk build that catches up within seconds installs at once and a long one is asked every 15 seconds.
+const NOT_READY_MS = [1_000, 2_000, 3_000, 5_000, 8_000, 11_000, 15_000];
+// A Room that locks offline stays readable this long after the connection drops, so a laptop waking or changing network keeps working while a disconnected device locks soon after.
+const LOCK_GRACE_MS = 120_000;
+function operationOf(input) {
+    const operation = input?.operation_id;
+    return typeof operation === 'string' ? operation : null;
+}
 export function composeRuntime(options) {
-    const period = options.discoveryIntervalMs ?? DEFAULT_DISCOVERY_INTERVAL_MS;
+    const localSaves = options.adapter.localSaves === true;
+    const roomTypes = roomTypesOf(options.adapter.roomTypes, options.adapter.nameableRoomTypes);
     let authorization = options.authorization;
-    let opening;
-    let store;
-    const replicas = new Map();
-    const pendings = new Map();
-    const roomDrafts = new Map();
-    const presentations = new Map();
-    const wanted = new Map();
-    let limits = [];
-    let capabilities = [];
-    function rewriting() {
-        return capabilities.some((capability) => capability.name === 'move-reference-rewrites')
-            ? 'provider'
-            : 'runtime';
-    }
-    const rooms = new Map();
+    let discoveries = 0;
+    const usableWhenHeld = options.usableWhenHeld ?? [];
+    const build = options.build ?? '';
+    const declared = new Map();
+    const unheldModels = new Map();
     const unreadable = new Set();
-    const models = new Map();
-    const liveModels = new Map();
-    const invalidModels = new Set();
-    const modelEpoch = new Map();
+    const builtIn = builtInModel(roomTypes);
+    const typedPaths = options.adapter.typedPaths ?? [];
     const discovered = new Map();
+    const journal = createLog();
+    const database = {
+        async ask(request) {
+            try {
+                return await options.database.ask(request);
+            }
+            catch (error) {
+                if (refusedForSpace(error))
+                    filled();
+                throw error;
+            }
+        },
+    };
+    const socket = createSocket(options.adapter);
+    const store = createStore({
+        database,
+        roomTypes,
+        builtIn,
+        typedPaths,
+        opening: open,
+        unpublished,
+    });
+    const { covering, durably, exclusive, composed, publication } = store;
+    const openLocal = store.open;
+    const isFenced = store.fences.has;
+    const storedRooms = store.rooms;
+    const recordAt = store.record;
+    const workOf = store.work;
+    const replicaOf = store.replica;
+    const draftsOf = store.drafts;
+    const draftOf = store.draft;
+    const reads = socket.reads;
     let roomsListed = false;
     const scopedRefusals = new Map();
-    const sourceRefusals = new Map();
-    const declarationRefusals = new Set();
-    function modelKey(locator, attached) {
-        return `${attached} ${locator}`;
-    }
-    function modelOf(locator, attached = 'collection') {
-        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);
+    function modelIn(locator, stored) {
+        if (refusal?.code === 'revoked-authorization')
+            return { status: 'unavailable', reason: 'revoked' };
+        return stored?.record.model ?? unheldModels.get(locator) ?? NO_MODEL;
     }
     function compositionFor(record) {
-        return compositionOf({
+        return composed({
             ...record,
-            model: savedModel(record.locator, 'collection'),
-            selectionModel: savedModel(record.locator, 'typed-selection'),
+            model: modelIn(record.locator, { record, indexed: true, documents: 0 }),
         });
     }
     let refusal = null;
     let storageLoss = null;
-    let status = STARTING;
+    let status = { state: 'syncing', providerUnreachable: false, resting: false };
     let shown = STARTING;
     let discoveryPaused = false;
-    let timer;
     let closed = false;
     let stopping = false;
-    let withdrawNotifications;
-    let handed;
-    const notices = new Map();
-    let chain = Promise.resolve();
-    let mutations = Promise.resolve();
-    let inflight = false;
-    let queued = false;
+    let underway = null;
+    let streamed = null;
+    const recovery = (options.recovery ?? createRecovery()).scope(ROOM_ATTEMPTS);
+    const repairing = new Set();
+    const calling = new Set();
+    const repairable = new Map();
+    const unready = new Map();
+    let complete = false;
+    let recorded = false;
+    const stale = new Set();
+    const reloadsDue = new Set();
+    const lanes = new Map();
+    const roomLanes = new Map();
+    let roomWork = 0;
+    const roomReads = { free: ROOM_READS, waiting: [] };
+    const working = new Set();
     const roomListeners = new Set();
+    const unlistedRooms = new Set();
     const refusalListeners = new Set();
     const storageLossListeners = new Set();
     const statusListeners = new Set();
     const queueSubscriptions = new Set();
-    const roomDraftListeners = new Set();
-    const presentationListeners = new Set();
-    const readSide = createReadSide();
-    let withdrawConversations;
-    let currencyQueued = false;
+    const liveQueries = createLiveQueries((plan, cover) => answeredPlan(plan, cover), () => covering());
+    const figures = createFigures({
+        cover: figuresCover,
+        rooms: async (rooms, since) => database.ask({
+            kind: 'replica.tallies',
+            totals: { ...(await planned(ROOM_TOTALS, null)), limit: null },
+            rooms,
+            since,
+        }),
+        conversations: (conversations, since) => database.ask({ kind: 'conversation.tallies', conversations, since }),
+    });
+    let currencyQueued = null;
+    const confirmed = new Set();
+    let lockGrace = null;
+    const lockListeners = new Set();
     let serviceMode = 'open';
     let haltedRefusal = false;
     let openSignals = 0;
     const serviceModeListeners = new Set();
+    const memberListeners = new Set();
+    let authorityChanges = 0;
+    const authorityChangeListeners = new Set();
+    const unpreparedDemand = new Set();
+    const unpreparable = new Set();
+    let preparing = false;
+    let persistence = options.shell.persistence;
+    let heldWhenOpened = false;
+    let full = false;
+    let probing = null;
+    let testing = null;
+    const readinessWatches = new Set();
+    let readinessQueued = false;
     const conversations = createConversationStore({
-        cards: declaredCards,
-        documents: (locator) => readSide.query(planOf({ rooms: [locator], select: 'all' }, roomFacts())),
         call: (name, input) => invokeAction(name, input),
+        history: (request) => readConversationHistory(request),
         durably,
+        local: () => openLocal(),
+        again: () => {
+            void ready.then(scheduleCurrency);
+        },
+        settled: () => {
+            show();
+        },
         stream: () => options.adapter.conversations,
         publish: publishChangeSet,
+        online: providerReached,
+        full: () => full,
         closed: () => closed,
+        unanswered: resendLater,
     });
-    const searchIndex = createSearchIndex({
-        documents: () => readSide.documents(),
-        document: (room, path) => readSide.document(room, path),
-        messages: () => conversations.messages(),
-        message: (conversation, identity) => conversations.message(conversation, identity),
+    const lastAnswers = readAnswers({
+        database,
+        build,
+        unkept: options.adapter.unkeptReads ?? [],
+        leading: options.adapter.leadingReads ?? [],
+        recovery: recovery.scope(),
+        call: (name, input) => md.call(name, input),
+        online: providerReached,
+        closed: () => closed,
+        full: () => full,
+        filled,
     });
-    const journal = createLog();
-    let notifyReady = () => { };
+    let readyFromStore = () => { };
     const ready = new Promise((resolve) => {
-        notifyReady = resolve;
+        readyFromStore = resolve;
     });
-    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)
-            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 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;
+    let notifyDiscovered = () => { };
+    const firstDiscovery = new Promise((resolve) => {
+        notifyDiscovered = resolve;
+    });
+    let roomsNamed = false;
+    const seeding = {
+        store,
+        reached: reads.reached,
+        listed: () => roomsListed,
+        declares: (room) => declared.has(room),
+    };
+    const drafting = {
+        store,
+        closed: () => closed,
+        publishChangeSet,
+        statusShown: () => moveTo(status),
+    };
+    const saver = {
+        store,
+        socket,
+        journal,
+        localSaves,
+        ready,
+        firstDiscovery,
+        full: () => full,
+        closed: () => closed,
+        refused: () => refusal !== null,
+        roomsNamed: () => roomsNamed,
+        authorized: () => authorization,
+        ensureAuthorization,
+        connectionNow,
+        scoped,
+        refuse,
+        compositionFor,
+        prepare,
+        publishChangeSet,
+        pendingShown,
+        submitLater: (locator) => submitLater(accepting, locator),
+    };
+    const accepting = {
+        ...saver,
+        recovery,
+        stopping: () => stopping,
+        paused: () => discoveryPaused,
+        continuing,
+        discovered: (locator) => discovered.get(locator),
+        readable(room) {
+            unreadable.delete(room.locator);
+            list(room, true);
+        },
+        unreadable: roomUnreadable,
+        advanced,
+        withhold,
+        writesHeld,
+        openSignals: () => openSignals,
+        haltedSince,
+        rest,
+        statusShown: () => moveTo(status),
+    };
+    const installer = {
+        store,
+        socket,
+        journal,
+        roomTypes,
+        builtIn,
+        typedPaths,
+        unheldModel: (locator) => unheldModels.get(locator),
+        recover: recoverReads,
+        queueReadiness,
+        sweep,
+        settle: (local, locator, work, record, queue, settling) => settle(saver, local, locator, work, record, queue, settling),
+        readied,
+        modelKept: (locator) => {
+            unheldModels.delete(locator);
+        },
+        name,
+        usable(room) {
+            stale.delete(room.locator);
+            unpreparable.delete(room.locator);
+            if (unreadable.delete(room.locator))
+                scopedRefusals.delete(room.locator);
+            list(room, true);
+        },
+        publishChangeSet,
+        unpair: (local) => unpair(accepting, local),
+        statusShown: () => moveTo(status),
+        submitLater: (locator) => submitLater(accepting, locator),
+    };
+    function notifyReady() {
+        notifyDiscovered();
+        readyFromStore();
+    }
+    async function attended() {
+        const held = await (await openLocal()).status();
+        const attentionRequired = held.returned.flatMap((record) => record.returned === null || isFenced(record.locator)
+            ? []
+            : [{ room: record.locator, path: record.path, returned: structuredClone(record.returned) }]);
+        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;
         });
-        return records.map(roomDraftOf);
-    }
-    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);
+        const changed = new Map();
+        if (!localSaves) {
+            for (const change of held.unsent) {
+                if (!isFenced(change.room))
+                    changed.set(`${change.room}\u0000${change.path}`, change);
+            }
         }
+        const unsent = [...changed]
+            .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+            .map(([, change]) => change);
+        return {
+            queued: !localSaves && held.queued.some((locator) => !isFenced(locator)),
+            lastCompleted: held.lastCompleted,
+            attentionRequired,
+            unsent,
+            reset: held.resets.reduce((earliest, { locator, reset }) => isFenced(locator) || (earliest !== null && earliest <= reset) ? earliest : reset, null),
+        };
     }
-    function presentationOf(app) {
-        const value = presentations.get(app);
-        return value === undefined ? null : structuredClone(value);
+    async function queuedWork() {
+        const held = await (await openLocal()).queued();
+        return !localSaves && held.some((locator) => !isFenced(locator));
     }
-    function emitPresentation(app) {
-        if (closed)
-            return;
-        for (const listener of presentationListeners) {
-            if (listener.app === app && listener.ready)
-                listener.notify(presentationOf(app));
+    function declarationOf(locator, stored) {
+        const held = declared.get(locator);
+        const room = stored?.record ?? held?.room ?? discovered.get(locator);
+        return room === undefined ? undefined : { room, available: held?.available ?? true };
+    }
+    function listedLocators(held) {
+        return [
+            ...declared.keys(),
+            ...[...held.keys()].filter((locator) => !declared.has(locator)),
+        ].filter((locator) => !isFenced(locator));
+    }
+    function selectionModel() {
+        return refusal?.code === 'revoked-authorization'
+            ? { status: 'unavailable', reason: 'revoked' }
+            : builtIn;
+    }
+    function listedRoom(locator, stored) {
+        const declaration = declarationOf(locator, stored);
+        if (declaration === undefined)
+            return undefined;
+        const { room, available } = declaration;
+        const selection = room.typedSelection ?? null;
+        return {
+            name: room.name,
+            locator,
+            handle: room.handle,
+            operations: room.operations,
+            replica: room.replica,
+            model: modelTypes(modelIn(locator, stored)),
+            typedSelection: selection === null ? null : { roots: selection.roots, model: modelTypes(selectionModel()) },
+            providerOwnedPaths: room.providerOwnedPaths,
+            roomVersion: stored?.record.roomVersion ?? null,
+            synchronizationAvailable: available,
+            refusal: scopedRefusals.get(locator) ?? null,
+            documents: stored?.documents ?? 0,
+        };
+    }
+    function listingOf(held) {
+        const listing = new Map();
+        for (const locator of listedLocators(held)) {
+            const room = listedRoom(locator, held.get(locator));
+            if (room !== undefined)
+                listing.set(locator, room);
+        }
+        return listing;
+    }
+    async function patchedListing(changed) {
+        if (roomsShown === null)
+            return null;
+        const held = await storedRooms([...changed]);
+        const listing = new Map(roomsShown);
+        for (const locator of changed) {
+            const room = isFenced(locator) ? undefined : listedRoom(locator, held.get(locator));
+            if (room === undefined || !listing.has(locator))
+                return null;
+            listing.set(locator, room);
         }
+        return listing;
     }
-    function pending() {
-        return [...replicas.values()].some((replica) => replica.queue.length > 0);
+    async function listingNow() {
+        return listingOf(await storedRooms());
     }
-    function attention() {
-        const attentionRequired = [];
-        for (const record of [...roomDrafts.values()].flatMap((room) => [...room.values()])) {
-            if (record.returned === null)
-                continue;
-            attentionRequired.push({
-                room: record.locator,
-                path: record.path,
-                returned: structuredClone(record.returned),
-            });
+    function lockedIn(listing, locator) {
+        return listing.get(locator)?.replica.offline === 'locked' && !confirmed.has(locator);
+    }
+    function shownRooms(listing) {
+        return structuredClone([...listing.values()].map(({ documents, ...room }) => lockedIn(listing, room.locator)
+            ? {
+                ...room,
+                model: modelTypes(NO_MODEL),
+                typedSelection: null,
+                documents: 0,
+                locked: true,
+            }
+            : { ...room, documents, locked: false }));
+    }
+    async function offlineModes() {
+        const modes = new Map();
+        for (const [locator, { room }] of declared) {
+            const declaration = room ?? discovered.get(locator);
+            if (declaration !== undefined)
+                modes.set(locator, declaration.replica.offline);
         }
-        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;
+        for (const [locator, { offline }] of (await covering()).rooms)
+            modes.set(locator, offline);
+        return modes;
+    }
+    async function locked(locator) {
+        if (isFenced(locator) || confirmed.has(locator))
+            return false;
+        const held = declared.get(locator)?.room ?? discovered.get(locator);
+        const mode = (await (await openLocal()).offline(locator)) ?? held?.replica.offline;
+        return mode === 'locked';
+    }
+    async function lockedRooms() {
+        return [...(await offlineModes())]
+            .filter(([locator, mode]) => mode === 'locked' && !confirmed.has(locator) && !isFenced(locator))
+            .map(([locator]) => locator)
+            .sort();
+    }
+    async function relocked(before) {
+        const after = await lockedRooms();
+        if (JSON.stringify(after) === JSON.stringify(before))
+            return;
+        journal.record(`locked ${after.length}`);
+        emitRooms();
+        for (const notify of [...lockListeners])
+            notify();
+    }
+    function confirmLocks(listed) {
+        if (!socket.isOpen())
+            return;
+        for (const room of listed) {
+            if (room.replica.admission === 'admitted')
+                confirmed.add(room.locator);
         }
-        return { attentionRequired, reset };
     }
-    function listed() {
-        return structuredClone([...rooms.values()]);
+    function connectionLost() {
+        if (lockGrace !== null || closed)
+            return;
+        lockGrace = setTimeout(() => {
+            lockGrace = null;
+            if (socket.isOpen() || closed)
+                return;
+            void lockedRooms().then((before) => {
+                confirmed.clear();
+                return relocked(before);
+            }, () => { });
+        }, LOCK_GRACE_MS);
+    }
+    function connectionLive() {
+        if (lockGrace !== null)
+            clearTimeout(lockGrace);
+        lockGrace = null;
     }
-    function roomFacts() {
-        const held = [...rooms.values()].map((room) => {
+    function watchLocks(notify) {
+        lockListeners.add(notify);
+        return () => {
+            lockListeners.delete(notify);
+        };
+    }
+    async function roomFacts(reach = null) {
+        const held = await storedRooms();
+        const rooms = [...listingOf(held).values()]
+            .filter((room) => holds(reach, room.locator))
+            .map((room) => {
+            const governed = governs(reach, room);
             const attached = [
-                modelOf(room.locator),
-                ...(room.typedSelection === null ? [] : [modelOf(room.locator, 'typed-selection')]),
+                ...(governed.collection ? [modelIn(room.locator, held.get(room.locator))] : []),
+                ...(governed.selection ? [builtIn] : []),
             ];
             return {
                 locator: room.locator,
@@ -246,152 +493,665 @@ export function composeRuntime(options) {
                 types: attached.flatMap((model) => model.status === 'unavailable' ? [] : Object.values(model.types)),
             };
         });
-        return { listed: roomsListed, rooms: held };
+        return { listed: roomsListed, rooms };
+    }
+    function emitRooms(changed) {
+        recoverReads();
+        queueReadiness();
+        return changed === undefined ? publishRooms('all') : publishRooms('changed', changed);
+    }
+    function emitKnownRooms() {
+        conversations.learned();
+        if (unlistedRooms.size === 0)
+            return;
+        void publishRooms('known');
     }
-    function emitRooms() {
-        const value = listed();
-        for (const listener of roomListeners)
-            listener(value);
+    let roomsOwed = null;
+    let roomsShown = null;
+    function publishRooms(mode, touched = []) {
+        if (closed)
+            return Promise.resolve();
+        if (roomsOwed !== null) {
+            roomsOwed.all ||= mode === 'all';
+            for (const locator of touched) {
+                (mode === 'changed' ? roomsOwed.changed : roomsOwed.counted).add(locator);
+            }
+            return roomsOwed.shown;
+        }
+        const owing = {
+            all: mode === 'all',
+            changed: new Set(mode === 'changed' ? touched : []),
+            counted: new Set(mode === 'changed' ? [] : touched),
+            shown: Promise.resolve(),
+        };
+        roomsOwed = owing;
+        owing.shown = publication(async () => {
+            const owed = owing;
+            if (roomsOwed === owing)
+                roomsOwed = null;
+            if (closed || (roomListeners.size === 0 && unlistedRooms.size === 0))
+                return;
+            const patched = owed.all || owed.changed.size === 0 || unlistedRooms.size > 0
+                ? null
+                : await patchedListing(new Set([...owed.changed, ...owed.counted]));
+            if (patched === null && owed.changed.size > 0)
+                owed.all = true;
+            if (patched === null && !owed.all && owed.counted.size > 0) {
+                const held = await covering().catch(() => null);
+                if (held === null)
+                    return;
+                owed.all = [...owed.counted].some((locator) => held.rooms.has(locator) &&
+                    roomsShown?.get(locator)?.documents !== held.rooms.get(locator).documents);
+                if (owed.all) {
+                    recoverReads();
+                    queueReadiness();
+                }
+                else if (unlistedRooms.size === 0)
+                    return;
+            }
+            const listing = patched ?? (await listingNow().catch(() => null));
+            if (listing === null || closed)
+                return;
+            const value = shownRooms(listing);
+            const joining = unlistedRooms.size > 0 &&
+                (roomsListed || listing.size > 0 || refusal !== null || status.providerUnreachable);
+            if (!owed.all && patched === null && !joining)
+                return;
+            const moved = owed.all ||
+                patched !== null ||
+                (roomsShown !== null && JSON.stringify(shownRooms(roomsShown)) !== JSON.stringify(value));
+            if (moved)
+                for (const listener of roomListeners)
+                    listener(value);
+            if (joining) {
+                for (const listener of [...unlistedRooms]) {
+                    unlistedRooms.delete(listener);
+                    roomListeners.add(listener);
+                    listener(value);
+                }
+            }
+            roomsShown = roomListeners.size === 0 ? null : listing;
+        });
+        return owing.shown;
     }
     function emitRefusal() {
+        queueReadiness();
         for (const listener of refusalListeners)
             listener(refusal);
+        emitKnownRooms();
     }
     function emitStorageLoss() {
+        queueReadiness();
         for (const listener of storageLossListeners)
             listener(storageLoss);
     }
+    function emitMember(member) {
+        for (const listener of memberListeners)
+            listener(member);
+    }
     function moveTo(next) {
         if (closed)
-            return;
+            return Promise.resolve();
         status = next;
-        show();
+        return show();
+    }
+    function transferring() {
+        return { ...status, state: 'syncing', resting: false };
     }
+    let statusOwed = null;
+    let statusShown = Promise.resolve();
     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);
+            return Promise.resolve();
+        queueReadiness();
+        emitKnownRooms();
+        const moved = { moving: status, current: conversations.current() };
+        if (statusOwed !== null) {
+            statusOwed.push(moved);
+            return statusShown;
+        }
+        const owed = [moved];
+        statusOwed = owed;
+        statusShown = publication(async () => {
+            if (statusOwed === owed)
+                statusOwed = null;
+            const held = await attended();
+            if (closed)
+                return;
+            for (const { moving, current } of owed) {
+                const state = moving.resting && held.queued ? 'pending' : moving.state;
+                const next = {
+                    state: state === 'synced' && !current ? 'syncing' : state,
+                    lastCompleted: held.lastCompleted,
+                    providerUnreachable: moving.providerUnreachable,
+                    attentionRequired: held.attentionRequired,
+                    unsent: held.unsent,
+                    reset: held.reset,
+                };
+                if (same(shown, next))
+                    continue;
+                shown = next;
+                for (const listener of statusListeners)
+                    listener(shown);
+            }
+        });
+        return statusShown;
     }
-    function entryOf(batch) {
-        const state = pendings.get(batch.id);
-        if (state?.accepted !== undefined) {
-            return Object.freeze({ batch, state: 'accepted', roomVersion: state.accepted });
-        }
+    function entryOf(states, batch) {
+        if (localSaves)
+            return Object.freeze({ batch, state: 'local' });
+        const state = states.get(batch.id);
         return Object.freeze({ batch, ...(state?.submission ?? { state: 'waiting' }) });
     }
-    function entriesOf(locator) {
-        const replica = replicas.get(locator);
-        if (replica === undefined)
+    async function entriesOf(locator) {
+        if (isFenced(locator))
             return [];
-        return replica.queue.map(entryOf);
+        const { queue, states } = await workOf(locator);
+        return queue.map((batch) => entryOf(states, batch));
     }
     function emitQueue(locator) {
-        const entries = entriesOf(locator);
-        for (const subscription of queueSubscriptions) {
-            if (subscription.locator === locator)
+        const listening = () => [...queueSubscriptions].filter((subscription) => subscription.locator === locator);
+        if (closed || listening().length === 0)
+            return Promise.resolve();
+        return publication(async () => {
+            if (closed || listening().length === 0)
+                return;
+            const entries = await entriesOf(locator);
+            if (closed)
+                return;
+            for (const subscription of listening())
                 subscription.notify(entries);
-        }
+        });
     }
     function applyChangeSet(set) {
-        readSide.apply(set);
-        searchIndex.changed(set);
+        liveQueries.touched(set);
+        figures.touched(set);
+    }
+    function recoverReads() {
+        liveQueries.recover();
+        figures.recover();
+    }
+    function unpublished(error) {
+        journal.record(`publication failed ${error instanceof Error ? error.name : 'unknown'}`);
+    }
+    async function prepareReplica(locator) {
+        for (;;) {
+            const held = (await storedRooms([locator])).get(locator);
+            if (held === undefined || closed || held.indexed)
+                return;
+            const key = held.record.key;
+            const done = await exclusive(async () => {
+                const local = await openLocal();
+                return store.rederive(local, key, composed(held.record));
+            });
+            if (!done.done)
+                continue;
+            if ((await storedRooms([locator])).get(locator)?.record.key !== key)
+                continue;
+            publishChangeSet(changeSet(locator, { documents: null }));
+            recoverReads();
+            queueReadiness();
+            return;
+        }
+    }
+    async function unprepared() {
+        const held = (await covering()).rooms;
+        return [...unpreparedDemand, ...held.keys()].find((locator) => !(held.get(locator)?.indexed ?? false) && !unpreparable.has(locator));
+    }
+    function unpreparedBy(locator, error) {
+        unpreparable.add(locator);
+        journal.record(`preparation failed ${locator} ${error instanceof Error ? error.name : 'unknown'}`);
+        queueReadiness();
+    }
+    function prepare(locators = []) {
+        for (const locator of locators)
+            unpreparedDemand.add(locator);
+        if (preparing)
+            return;
+        preparing = true;
+        void (async () => {
+            try {
+                for (let waiting = await unprepared(); waiting !== undefined; waiting = await unprepared()) {
+                    await yielded();
+                    if (closed)
+                        return;
+                    unpreparedDemand.delete(waiting);
+                    await prepareReplica(waiting).catch((error) => unpreparedBy(waiting, error));
+                }
+            }
+            catch {
+                journal.record('preparation failed');
+            }
+            finally {
+                preparing = false;
+            }
+        })();
+    }
+    function roomsOfReach(reach) {
+        return new Set([...reach.rooms, ...reach.documents.map(roomOfKey)]);
+    }
+    function everyRoom(held) {
+        return [...new Set([...declared.keys(), ...held.rooms.keys(), ...held.queues.keys()])];
+    }
+    function reachedRooms(plan, held) {
+        const reached = plan.reach === null ? null : roomsOfReach(plan.reach);
+        const named = plan.rooms ?? (reached === null ? everyRoom(held) : [...reached]);
+        return [...new Set(named)]
+            .filter((locator) => (reached === null || reached.has(locator)) && !plan.locked.includes(locator))
+            .sort();
+    }
+    function awaited(locator) {
+        return (!roomsListed ||
+            (declared.has(locator) && discovered.get(locator)?.replica.admission === 'admitted'));
+    }
+    function covered(plan, held) {
+        return coveredRooms(reachedRooms(plan, held), plan.rooms === null && plan.reach === null, held);
+    }
+    async function figuresCover() {
+        const held = await covering();
+        const locked = await lockedRooms();
+        const cover = coveredRooms(everyRoom(held)
+            .filter((locator) => !locked.includes(locator))
+            .sort(), true, held);
+        awaitPreparation(cover);
+        return 'pending' in cover ? cover : { rooms: cover.rooms };
+    }
+    function coveredRooms(locators, whole, held) {
+        if (locators.length === 0 && whole && !roomsListed)
+            return { pending: [] };
+        const pending = [];
+        const coverage = [];
+        const overlay = [];
+        const read = [];
+        for (const locator of locators) {
+            const replica = held.rooms.get(locator);
+            if (replica === undefined) {
+                if (awaited(locator))
+                    pending.push({ room: locator, awaits: 'acquisition' });
+                continue;
+            }
+            if (!replica.indexed) {
+                pending.push({ room: locator, awaits: 'preparation' });
+                continue;
+            }
+            coverage.push({
+                room: locator,
+                generation: replica.transfer,
+                current: !roomInFlight(store, locator),
+            });
+            read.push({ locator, key: replica.key });
+            for (const id of held.queues.get(locator) ?? [])
+                overlay.push(id);
+        }
+        if (pending.length > 0)
+            return { pending };
+        return { coverage: { rooms: coverage, indexes: [], overlay }, rooms: read };
+    }
+    function awaitPreparation(cover) {
+        if (!('pending' in cover))
+            return;
+        const waiting = cover.pending.filter(({ awaits }) => awaits === 'preparation');
+        if (waiting.length > 0)
+            prepare(waiting.map(({ room }) => room));
+    }
+    function requiredRooms(given, held) {
+        const reach = planReach(given);
+        const listed = new Set(listedLocators(held));
+        if (reach === null)
+            return { listed: roomsListed, rooms: [...listed].sort() };
+        const named = [...roomsOfReach(reach)].sort();
+        if (roomsListed)
+            return { listed: true, rooms: named.filter((room) => listed.has(room)) };
+        return { listed: named.every((room) => held.has(room)), rooms: named };
+    }
+    function roomState(locator, held) {
+        const listedRoom = discovered.get(locator);
+        if (roomsListed &&
+            (listedRoom === undefined ||
+                listedRoom.replica.admission !== 'admitted' ||
+                unreadable.has(locator)))
+            return 'unadmitted';
+        const stored = held.get(locator);
+        if (stored === undefined)
+            return 'acquiring';
+        if (!stored.indexed)
+            return 'preparing';
+        return 'complete';
+    }
+    function conversationCoverage(reach) {
+        const declaredConversations = reach === null || reach.conversations;
+        if (!declaredConversations || options.adapter.conversations === undefined)
+            return 'undeclared';
+        if (!conversations.known() || !conversations.current())
+            return 'acquiring';
+        return 'complete';
+    }
+    function connectionOf(lastCompleted) {
+        if (socket.isOpen())
+            return 'connected';
+        if (status.providerUnreachable)
+            return 'unreachable';
+        return options.adapter.roomStream === undefined && lastCompleted !== null
+            ? 'connected'
+            : 'connecting';
+    }
+    async function connectionNow() {
+        if (socket.isOpen() || status.providerUnreachable || options.adapter.roomStream !== undefined) {
+            return connectionOf(null);
+        }
+        return connectionOf((await (await openLocal()).facts()).lastCompleted);
+    }
+    async function readinessHeld() {
+        const local = await openLocal();
+        const [held, facts] = await Promise.all([covering(), local.facts()]);
+        return { held: held.rooms, facts };
+    }
+    function readinessFor(port, reach, { held, facts }) {
+        const required = requiredRooms(reach, held);
+        const coverage = required.rooms.map((room) => ({ room, state: roomState(room, held) }));
+        const preparing = coverage
+            .filter((room) => room.state === 'preparing' && !unpreparable.has(room.room))
+            .map(({ room }) => room);
+        if (preparing.length > 0)
+            prepare(preparing);
+        return readinessOf({
+            code: port.code,
+            coverage: {
+                listed: required.listed,
+                rooms: coverage,
+                conversations: conversationCoverage(reach),
+            },
+            persistence,
+            connection: connectionOf(facts.lastCompleted),
+            house: refusal !== null ? 'refused' : writesHeld() ? 'write-halted' : 'open',
+            space: full ? 'full' : null,
+            installation: installationOf(store, coverage, held),
+            lost: storageLoss !== null,
+            established: facts.targets[port.target]?.established === true ||
+                (heldWhenOpened && usableWhenHeld.includes(port.target)),
+        });
+    }
+    const establishing = new Set();
+    function establish(name) {
+        if (establishing.has(name))
+            return;
+        establishing.add(name);
+        void durably(async (local) => {
+            const { targets } = await local.facts();
+            await local.fact('targets', { ...targets, [name]: { established: true } });
+        })
+            .then(() => {
+            queueReadiness();
+            void probeEachMinute();
+        }, () => {
+            journal.record(`target record failed ${name}`);
+        })
+            .finally(() => establishing.delete(name));
+    }
+    function deliverReadiness(watch, held) {
+        if (!readinessWatches.has(watch))
+            return;
+        const readiness = readinessFor(watch.port, watch.reach, held);
+        if (readiness.ready && held.facts.targets[watch.port.target]?.established !== true) {
+            establish(watch.port.target);
+        }
+        const shownReadiness = JSON.stringify(readiness);
+        if (shownReadiness === watch.last)
+            return;
+        watch.last = shownReadiness;
+        watch.deliver(structuredClone(readiness));
+    }
+    let readinessShown = Promise.resolve();
+    const readinessOwed = new Set();
+    function deliverAll(watches) {
+        const queued = readinessOwed.size > 0;
+        for (const watch of watches)
+            readinessOwed.add(watch);
+        if (queued)
+            return;
+        readinessShown = readinessShown
+            .then(async () => {
+            const owed = [...readinessOwed];
+            readinessOwed.clear();
+            const held = await readinessHeld();
+            if (closed)
+                return;
+            for (const watch of owed)
+                deliverReadiness(watch, held);
+        })
+            .catch(unpublished);
+    }
+    function queueReadiness() {
+        if (readinessQueued || closed || readinessWatches.size === 0)
+            return;
+        readinessQueued = true;
+        queueMicrotask(() => {
+            readinessQueued = false;
+            if (closed)
+                return;
+            deliverAll([...readinessWatches]);
+        });
+    }
+    function watchReadiness(port, reach, deliver) {
+        const watch = { port, reach, deliver, last: null };
+        readinessWatches.add(watch);
+        void openLocal().then(() => deliverAll([watch]), () => deliverAll([watch]));
+        return () => {
+            readinessWatches.delete(watch);
+        };
+    }
+    function providerReached() {
+        return (socket.isOpen() || !status.providerUnreachable) && refusal === null;
+    }
+    function filled() {
+        if (full || closed)
+            return;
+        full = true;
+        journal.record('space full');
+        queueReadiness();
+        void probeEachMinute();
+    }
+    async function installedTarget() {
+        if (heldWhenOpened && usableWhenHeld.length > 0)
+            return true;
+        const { targets } = await (await openLocal()).facts();
+        return Object.values(targets).some((target) => target.established);
+    }
+    async function probeEachMinute() {
+        if (!full || probing !== null || closed)
+            return;
+        if (!(await installedTarget().catch(() => false)))
+            return;
+        if (!full || probing !== null || closed)
+            return;
+        // A device whose storage filled after its install tries a write each minute, so space freed elsewhere ends its read-only mode without a Retry.
+        probing = setInterval(() => {
+            void probed();
+        }, 60_000);
+    }
+    function probed() {
+        testing ??= database.ask({ kind: 'space.probe' }).then(() => {
+            testing = null;
+            spaceFreed();
+            return true;
+        }, () => {
+            testing = null;
+            return false;
+        });
+        return testing;
+    }
+    function spaceFreed() {
+        if (!full)
+            return;
+        full = false;
+        if (probing !== null)
+            clearInterval(probing);
+        probing = null;
+        unpreparable.clear();
+        journal.record('space freed');
+        queueReadiness();
+        if (closed || authorization === undefined)
+            return;
+        if (options.adapter.roomStream === undefined)
+            void sync('unstreamed', null);
+        else
+            void resynchronize();
+    }
+    function sameCover(left, right) {
+        return JSON.stringify(left) === JSON.stringify(right);
+    }
+    async function coveredRows(plan, cover) {
+        for (;;) {
+            const before = await cover();
+            if ('pending' in before)
+                return { pending: before };
+            const local = await openLocal();
+            const keys = before.rooms.map(({ key }) => key);
+            const changes = local.changes(keys);
+            const current = () => local.changes(keys) === changes;
+            const rows = await windowRows(local, plan, before.rooms, current);
+            const after = await cover();
+            if (rows !== null && sameCover(before, after))
+                return { rows, cover: before, current };
+        }
+    }
+    async function windowRows(local, plan, rooms, unchanged) {
+        const first = await local.query(plan, rooms, QUERY_BYTES);
+        if (first.more === undefined || !('documents' in first)) {
+            const { more: _more, ...rows } = first;
+            return rows;
+        }
+        const documents = [...first.documents];
+        for (let more = first.more; more !== undefined;) {
+            if (!unchanged())
+                return null;
+            const page = await local.query({
+                ...plan,
+                after: { text: more, values: JSON.parse(more) },
+                limit: plan.limit === null ? null : plan.limit - documents.length,
+                total: false,
+            }, rooms, QUERY_BYTES);
+            if (!('documents' in page))
+                return null;
+            documents.push(...page.documents);
+            more = page.more;
+            if (more === undefined) {
+                return {
+                    documents,
+                    ...(page.next === undefined ? {} : { next: page.next }),
+                    ...(first.total === undefined ? {} : { total: first.total }),
+                };
+            }
+        }
+        return null;
+    }
+    function keyedOf(rows, coverage) {
+        if ('groups' in rows) {
+            return {
+                result: { ...rows, coverage },
+                keys: rows.groups.map((group) => JSON.stringify(group.key)),
+            };
+        }
+        return {
+            result: { ...rows, coverage },
+            keys: rows.documents.map((document) => documentKey(document.room, document.path)),
+        };
+    }
+    async function answeredPlan(plan, cover) {
+        const answered = await coveredRows(plan, cover);
+        if ('pending' in answered) {
+            const pending = answered.pending;
+            return { result: pending, keys: [], current: () => true };
+        }
+        const held = answered.cover;
+        return { ...keyedOf(answered.rows, held.coverage), current: answered.current };
+    }
+    async function coverNow(plan) {
+        const cover = covered(plan, await covering());
+        awaitPreparation(cover);
+        return cover;
+    }
+    async function rowsQuery(plan) {
+        const held = await covering();
+        const before = covered(plan, held);
+        awaitPreparation(before);
+        const seeded = seedApplies(seeding, plan, held);
+        if (seeded !== null)
+            return seededResult(seeded).result;
+        if ('pending' in before)
+            return before;
+        const answered = await coveredRows(plan, () => coverNow(plan));
+        if ('pending' in answered)
+            return answered.pending;
+        const shownCover = answered.cover;
+        return { ...answered.rows, coverage: shownCover.coverage };
     }
     function publishChangeSet(set) {
         applyChangeSet(set);
+        for (const { locator, path } of set.documents) {
+            if (path !== null)
+                store.attached.drop(locator, path);
+        }
+        const shownNow = [];
+        if (set.queues.length > 0 || set.drafts.length > 0)
+            shownNow.push(show());
         if (set.rooms.length > 0)
-            emitRooms();
+            shownNow.push(emitRooms(set.rooms));
+        else if (set.documents.length > 0) {
+            shownNow.push(publishRooms('counted', [...new Set(set.documents.map(({ locator }) => locator))]));
+        }
         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);
+            shownNow.push(emitQueue(locator));
+        if (set.drafts.length > 0)
+            shownNow.push(publishRoomDrafts(drafting, false));
+        else if (set.documents.length > 0) {
+            shownNow.push(publishRoomDrafts(drafting, false, set.documents));
         }
         for (const app of set.presentations)
-            emitPresentation(app);
+            shownNow.push(emitPresentation(drafting, app));
         conversations.changed(set);
-        const cards = declaredCards();
-        if (cards !== undefined && set.documents.some((change) => change.locator === cards.locator)) {
-            scheduleCurrency();
-        }
-    }
-    function stopTimer() {
-        if (timer === undefined)
-            return;
-        clearInterval(timer);
-        timer = undefined;
-    }
-    function startTimer() {
-        if (timer !== undefined)
-            return;
-        timer = setInterval(() => {
-            void enqueue();
-        }, period);
+        return Promise.all(shownNow).then(() => undefined);
     }
     async function refuse(reason, provider = null) {
-        stopTimer();
         discoveryPaused = true;
+        socket.abortReads();
         try {
             if (reason === 'revoked-authorization') {
                 await exclusive(async () => {
                     const revoked = { status: 'unavailable', reason: 'revoked' };
+                    let held = new Map();
                     try {
                         const local = await openLocal();
-                        await local.revokeModels([...replicas.values()].map((replica) => ({
-                            record: replica.confirmed.record,
-                            queue: replica.queue,
-                        })));
+                        held = await storedRooms();
+                        await local.commit({
+                            rooms: [...held.values()].map(({ record: kept }) => {
+                                const record = { ...kept, model: revoked };
+                                return {
+                                    locator: record.locator,
+                                    key: record.key,
+                                    record: storedRecord(record),
+                                    composed: composedOf(composed(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);
-                        modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
-                        models.set(key, revoked);
-                        liveModels.delete(key);
+                    const listedNow = listedLocators(held);
+                    for (const locator of listedNow) {
+                        if (!held.has(locator))
+                            unheldModels.set(locator, revoked);
                     }
-                    const changed = [];
-                    for (const [locator, room] of rooms) {
-                        const before = replicas.get(locator) ?? null;
-                        if (before !== null) {
-                            const record = {
-                                ...before.confirmed.record,
-                                model: revoked,
-                                selectionModel: revoked,
-                            };
-                            const read = readConfirmed(record, before.confirmed);
-                            replicas.set(locator, read.kind === 'staged'
-                                ? replicaOf(read.confirmed, before.queue, rewriting(), before)
-                                : { ...before, confirmed: { ...before.confirmed, record } });
-                        }
-                        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));
+                    publishChangeSet(mergeChangeSets(listedNow.map((locator) => changeSet(locator, { documents: null, room: true }))));
+                    prepare();
                 });
             }
         }
         finally {
             refusal = {
-                reason,
+                code: reason,
+                retryable: false,
                 reauthorizationOffered: reason === 'revoked-authorization',
                 refusal: provider,
             };
@@ -400,193 +1160,162 @@ export function composeRuntime(options) {
         }
     }
     function list(room, synchronizationAvailable) {
-        const selection = room.typedSelection ?? null;
-        rooms.set(room.locator, {
-            name: room.name,
-            locator: room.locator,
-            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')),
-                },
-            providerOwnedPaths: room.providerOwnedPaths,
-            roomVersion: replicas.get(room.locator)?.confirmed.record.roomVersion ?? null,
-            attachments: replicas.get(room.locator)?.confirmed.record.attachments ?? [],
-            synchronizationAvailable,
-            refusal: scopedRefusals.get(room.locator) ?? sourceRefusals.get(room.locator) ?? null,
+        if (isFenced(room.locator))
+            return;
+        declared.set(room.locator, {
+            room: {
+                name: room.name,
+                locator: room.locator,
+                handle: room.handle,
+                operations: room.operations,
+                replica: room.replica,
+                typedSelection: room.typedSelection ?? null,
+                providerOwnedPaths: room.providerOwnedPaths,
+            },
+            available: synchronizationAvailable,
         });
     }
-    async function applyDiscovery(listed, local) {
-        const listedLocators = new Set(listed.map((room) => room.locator));
-        for (const locator of listedLocators)
+    function listHeld(locator) {
+        if (isFenced(locator))
+            return;
+        declared.set(locator, { room: null, available: false });
+    }
+    async function applyDiscovery(found, started, left) {
+        const lockedBefore = await lockedRooms();
+        const local = await openLocal();
+        const stillFenced = new Set(await local.fences());
+        const relisting = found
+            .map(({ locator }) => locator)
+            .filter((locator) => {
+            const fence = store.fences.of(locator);
+            return stillFenced.has(locator) && (fence === undefined || fence.at < started);
+        });
+        const relisted = relisting.length === 0 ? new Set() : await durably((held) => held.unfence(relisting));
+        for (const { locator } of found) {
+            const fence = store.fences.of(locator);
+            if (fence === undefined || fence.at >= started)
+                continue;
+            if (relisted.has(locator) || (!stillFenced.has(locator) && !fence.written)) {
+                store.fences.lift(locator);
+            }
+        }
+        const kept = await local.held();
+        await loseRooms(found
+            .filter((room) => room.replica.admission !== 'admitted' &&
+            (kept.held.has(room.locator) || store.installs.of(room.locator).transfer !== null))
+            .map((room) => room.locator));
+        const listed = found.filter(({ locator }) => !isFenced(locator) && (!stillFenced.has(locator) || relisted.has(locator)));
+        const listedLocatorsNow = new Set(listed.map((room) => room.locator));
+        for (const locator of listedLocatorsNow)
             scopedRefusals.delete(locator);
-        discovered.clear();
+        if (left === undefined)
+            discovered.clear();
         for (const room of listed)
             discovered.set(room.locator, room);
-        for (const locator of wanted.keys())
-            if (!listedLocators.has(locator))
-                wanted.delete(locator);
-        await dropUnlisted(listedLocators, local);
+        const named = new Set(found.map((room) => room.locator));
+        await loseRooms(left ??
+            [...new Set([...declared.keys(), ...kept.held, ...store.installs.transferring()])].filter((locator) => !named.has(locator)));
+        const held = await storedRooms(listed.map((room) => room.locator));
         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);
+            const record = held.get(room.locator)?.record;
+            if (record !== undefined && record.replica.selection !== room.replica.selection) {
+                listHeld(room.locator);
                 continue;
             }
             list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
         }
+        confirmLocks(listed);
         roomsListed = true;
         emitRooms();
-    }
-    function unlistedHeld(listed) {
-        return [...new Set([...rooms.keys(), ...roomDrafts.keys()])].filter((locator) => !listed.has(locator));
-    }
-    async function dropUnlisted(listed, local) {
-        if (unlistedHeld(listed).length === 0)
+        await relocked(lockedBefore);
+        return listed;
+    }
+    function forget(locator) {
+        confirmed.delete(locator);
+        forgetInstall(store, locator);
+        declared.delete(locator);
+        discovered.delete(locator);
+        unreadable.delete(locator);
+        stale.delete(locator);
+        repairable.delete(locator);
+        unpreparable.delete(locator);
+        scopedRefusals.delete(locator);
+        unheldModels.delete(locator);
+        store.forget(locator);
+    }
+    async function eraseFenced(locators) {
+        for (const locator of locators) {
+            while (await durably((local) => local.erase(locator, ERASE_BATCH)))
+                await yielded();
+        }
+    }
+    let sweeping = false;
+    function sweep() {
+        if (sweeping || closed)
             return;
-        await exclusive(async () => {
-            const unlisted = unlistedHeld(listed);
-            await local.dropRooms(unlisted);
-            const removed = unlisted.map((locator) => changeSet(locator, replicas.get(locator) ?? null, null, {
-                room: true,
-                queue: true,
-                drafts: [...(roomDrafts.get(locator)?.keys() ?? [])],
-            }));
-            for (const locator of unlisted) {
-                for (const batch of replicas.get(locator)?.queue ?? [])
-                    pendings.delete(batch.id);
-                replicas.delete(locator);
-                rooms.delete(locator);
-                roomDrafts.delete(locator);
-                unreadable.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);
-                    modelEpoch.delete(key);
+        sweeping = true;
+        void (async () => {
+            try {
+                while (!closed && (await durably((local) => local.erase(null, ERASE_BATCH)))) {
+                    await yielded();
                 }
-                journal.record(`room unlisted ${locator}`);
             }
-            publishChangeSet(mergeChangeSets(removed));
-            moveTo({ ...status, ...attention() });
-        });
-    }
-    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);
-            invalidModels.add(key);
-        }
-        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);
-            invalidModels.delete(key);
-        }
-        return model;
-    }
-    async function hydrate(opened) {
-        const [records, queues, kept, presented, held, chatDrafts, lastCompleted, declared, named] = await Promise.all([
-            opened.all(),
-            opened.queues(),
-            opened.roomDrafts(),
-            opened.presentation(),
-            opened.conversations(),
-            opened.chatDrafts(),
-            opened.lastCompleted(),
-            opened.providerLimits(),
-            opened.capabilities(),
-        ]);
-        limits = declared;
-        capabilities = named;
-        roomDrafts.clear();
-        for (const record of kept)
-            rememberRoomDraft(record);
-        presentations.clear();
-        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) {
-            const model = restored(modelKey(record.locator, 'collection'), record.model);
-            const selectionModel = restored(modelKey(record.locator, 'typed-selection'), record.selectionModel);
-            const prior = previousReplicas.get(record.locator);
-            const retyped = { ...record, model, selectionModel };
-            const read = readConfirmed(retyped, prior?.confirmed);
-            const confirmed = read.kind === 'staged'
-                ? read.confirmed
-                : {
-                    record: retyped,
-                    collection: parseCollection(retyped.documents, compositionOf(retyped)),
-                };
-            replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? [], rewriting(), prior));
-            const existing = rooms.get(record.locator);
-            if (existing === undefined)
-                list(record, false);
-            else {
-                rooms.set(record.locator, {
-                    ...existing,
-                    roomVersion: record.roomVersion,
-                    attachments: record.attachments,
-                    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),
-                        },
-                });
+            catch {
+                journal.record('erasure failed');
             }
-            if (read.kind === 'refused') {
-                refusedSource(record, read);
-                declarationRefusals.add(record.locator);
+            finally {
+                sweeping = false;
             }
+        })();
+    }
+    function fenceLive(locators) {
+        for (const locator of new Set(locators)) {
+            if (!store.fences.raise(locator, discoveries))
+                continue;
+            forget(locator);
+            journal.record(`room lost ${locator}`);
         }
-        return {
-            lastCompleted,
-            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, read } = await hydrate(opened);
-        applyChangeSet(read);
-        if (replicas.size > 0)
-            emitRooms();
-        for (const locator of locators)
-            emitQueue(locator);
-        publishRoomDrafts(false);
-        return lastCompleted;
+    async function loseRooms(locators) {
+        fenceLive(locators);
+        const fresh = [...new Set(locators)].filter((locator) => {
+            const fence = store.fences.of(locator);
+            if (fence === undefined || fence.written)
+                return false;
+            store.fences.mark(locator, true);
+            return true;
+        });
+        if (fresh.length === 0)
+            return;
+        let held = [];
+        try {
+            await durably(async (local) => {
+                held = await local.roomDrafts();
+                await local.fence(fresh);
+            });
+        }
+        catch (error) {
+            for (const locator of fresh)
+                store.fences.mark(locator, false);
+            throw error;
+        }
+        finally {
+            publishChangeSet(mergeChangeSets(fresh.map((locator) => changeSet(locator, {
+                documents: null,
+                room: true,
+                queue: true,
+                drafts: held.filter((draft) => draft.locator === locator).map(({ path }) => path),
+            }))));
+            recoverReads();
+            moveTo(status);
+        }
+        await durably((local) => unpair(accepting, local));
+        await eraseFenced(fresh);
     }
-    async function open() {
-        const opened = await openRuntimeStore();
-        store = opened;
+    async function open(opened) {
+        if (closed)
+            throw new Error('runtime closed');
+        const interrupted = await opened.fences();
         const kept = options.shell.generation;
         const storedGeneration = await opened.generation();
         const loss = detectStorageLoss(storedGeneration, kept);
@@ -599,202 +1328,51 @@ export function composeRuntime(options) {
             storageLoss = loss;
             emitStorageLoss();
         }
-        const lastCompleted = await readState(opened);
-        moveTo({ ...status, lastCompleted, ...attention() });
-        return opened;
-    }
-    function durably(work) {
-        return exclusive(async () => {
-            const local = await openLocal();
-            return work(local);
-        });
-    }
-    function openLocal() {
-        opening ??= open().catch((error) => {
-            opening = undefined;
-            throw error;
-        });
-        return opening;
-    }
-    function exclusive(work) {
-        const next = mutations.then(work, work);
-        mutations = next.then(() => undefined, () => undefined);
-        return next;
-    }
-    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 withdrawn = withdrawals(confirmed, queue, withdrawable, rewriting());
-        const kept = queue.filter((batch) => !withdrawn.includes(batch));
-        const returning = [
-            ...withdrawn.map((batch) => ({ batch, returned: { kind: 'withdrawn' } })).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.write({
-            next: confirmed.record,
-            previous: before?.confirmed.record ?? null,
-            queue: kept,
-            previousQueue: before?.queue ?? [],
-            roomDrafts: [...written.values()],
-        });
-        for (const batch of before?.queue ?? []) {
-            if (!kept.includes(batch))
-                pendings.delete(batch.id);
-        }
-        for (const record of written.values())
-            rememberRoomDraft(record);
-        for (const batch of withdrawn)
-            journal.record(`outcome ${locator} ${batch.id} withdrawn`);
-        replicas.set(locator, replicaOf(confirmed, kept, rewriting(), before));
-        return changeSet(locator, before ?? null, replicas.get(locator) ?? null, {
-            room: settling.room,
-            queue: kept.length !== (before?.queue.length ?? 0),
-            drafts: [...written.keys()],
-        });
-    }
-    function publish(local, room, confirmed) {
-        return exclusive(async () => {
-            if (!continuing())
-                return;
-            const prior = replicas.get(room.locator);
-            const retained = readConfirmed({
-                ...confirmed.record,
-                model: modelOf(room.locator),
-                selectionModel: modelOf(room.locator, 'typed-selection'),
-            }, prior?.confirmed);
-            if (retained.kind !== 'staged')
-                throw new Error(`Cannot retype staged Room ${room.locator}`);
-            const queue = prior?.queue ?? [];
-            const roomVersion = retained.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, retained.confirmed, queue.filter((batch) => !accepted.includes(batch)), { room: true });
-            const target = wanted.get(room.locator);
-            if (target !== undefined && options.adapter.reached(room.locator, roomVersion, target)) {
-                wanted.delete(room.locator);
-            }
-            unreadable.delete(room.locator);
-            sourceRefusals.delete(room.locator);
-            declarationRefusals.delete(room.locator);
-            list(room, true);
-            publishChangeSet(set);
-            moveTo({ ...status, ...attention() });
-        });
-    }
-    async function saveRoomDrafts(locator, named, writtenBy) {
-        const local = await openLocal();
-        const replica = replicas.get(locator);
-        const room = rooms.get(locator);
-        if (replica === undefined || room === undefined) {
-            throw new Error(`No Local Replica for ${locator}`);
-        }
-        const saved = [];
-        for (const { path, revision } of named) {
-            const record = roomDrafts.get(locator)?.get(path);
-            if (record === undefined || record.revision !== revision) {
-                return { outcome: 'refused', rule: 'stale', 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', rule: 'changed-underneath', parts: changed };
-        const parts = saved.map(({ path, parts }) => changesOf(path, parts));
-        const built = buildBatch({
-            baseRoomVersion: replica.confirmed.record.roomVersion,
-            composition: compositionFor(replica.confirmed.record),
-            operations: room.operations,
-            providerOwnedPaths: room.providerOwnedPaths,
-            providerLimits: limits,
-            rewriting: rewriting(),
-            visible: replica.visible,
-            changes: parts.flatMap(({ changes }) => changes),
-            bases: parts.flatMap(({ bases }) => bases),
-            writtenBy,
-        });
-        if (built.kind === 'refused')
-            return { outcome: 'refused', ...built.refusal };
-        const batches = [...replica.queue, built.batch];
-        const consumed = saved.map(({ path }) => path);
+        const held = await opened.opened();
+        heldWhenOpened = usableWhenHeld.length > 0 && (await opened.covering()).rooms.size > 0;
         try {
-            await local.write({
-                next: replica.confirmed.record,
-                previous: replica.confirmed.record,
-                queue: batches,
-                previousQueue: replica.queue,
-                saved,
-                consumedRoomDrafts: consumed,
-            });
+            await opened.demote();
+            await database.ask({ kind: 'read.builds', build });
+            for (const key of held.orphans)
+                await opened.release(key);
         }
-        catch {
-            return { outcome: 'refused', rule: 'durable-write' };
-        }
-        pendings.set(built.batch.id, { drafts: saved, submission: { state: 'waiting' }, lost: false });
-        for (const path of consumed)
-            forgetRoomDraft(locator, path);
-        replicas.set(locator, replicaOf(replica.confirmed, batches, rewriting(), replica));
-        publishChangeSet(changeSet(locator, replica, replicas.get(locator) ?? null, {
-            queue: true,
-            drafts: consumed,
-        }));
-        moveTo({ ...saving(status), ...attention() });
-        void enqueue();
-        return { outcome: 'saved', identifier: built.batch.id };
-    }
-    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;
+        catch (error) {
+            if (!refusedForSpace(error))
+                throw error;
+        }
+        if (held.erasing || held.orphans.length > 0)
+            queueMicrotask(sweep);
+        await conversations.opened(opened);
+        if (interrupted.length > 0) {
+            queueMicrotask(() => {
+                void eraseFenced(interrupted).catch(() => {
+                    journal.record('erasure failed');
+                });
+            });
         }
-        await local.submit(locator, identifier, submission, lost);
-        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);
-        pendings.set(identifier, { ...pendings.get(identifier), upload });
-        if (!continuing())
-            throw new Error('connection refused');
+        moveTo(status);
+        prepare();
+        emitRooms();
+        void exclusive(() => unpair(accepting, opened)).catch(() => {
+            journal.record('unpair failed');
+        });
+        return opened;
     }
     async function readHistory(locator, path, query = {}) {
         if (closed || refusal !== null)
-            return { kind: 'transport-uncertainty' };
+            return UNCERTAIN;
+        await firstDiscovery;
+        if (!roomsNamed)
+            return UNCERTAIN;
         try {
             await ensureAuthorization();
         }
         catch {
-            return { kind: 'transport-uncertainty' };
-        }
-        if (closed || authorization === undefined || refusal !== null) {
-            return { kind: 'transport-uncertainty' };
+            return UNCERTAIN;
         }
+        if (closed || authorization === undefined || refusal !== null)
+            return UNCERTAIN;
+        const since = store.fences.count();
         const transfer = ['transfer', 'history', locator, path];
         if (query.revision !== undefined)
             transfer.push(query.revision);
@@ -809,29 +1387,64 @@ export function composeRuntime(options) {
                 ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
             });
             journal.record(`outcome history ${result.kind}`);
+            if (store.fences.since(locator, since))
+                return failure({ kind: 'room-not-readable', locator });
             if (result.kind === 'scoped-refusal') {
-                const room = replicas.get(result.locator)?.confirmed.record;
+                const room = await recordAt(result.locator);
                 if (room !== undefined)
                     await scoped(result, room, await openLocal());
             }
             if (result.kind === 'revoked-authorization')
                 await refuse('revoked-authorization');
-            return result;
+            return historyAnswer(result);
         }
         catch {
             journal.record('outcome history transport-uncertainty');
-            return { kind: 'transport-uncertainty' };
-        }
-    }
-    function declaredCards() {
-        for (const capability of capabilities) {
-            if (capability.conversationCards !== undefined)
-                return capability.conversationCards;
-        }
-        return undefined;
-    }
-    function declaredAction(name) {
-        for (const capability of capabilities) {
+            return UNCERTAIN;
+        }
+    }
+    async function located(room, path, destination) {
+        const crossing = roomTarget(destination);
+        const listing = await listingNow();
+        if (crossing === null) {
+            const named = target(path, destination);
+            return named === null || !listing.has(room) ? null : { room, path: named };
+        }
+        const held = [...listing.values()].find((listed) => listed.handle === crossing.handle);
+        return held === undefined ? null : { room: held.locator, path: crossing.path };
+    }
+    async function resolveReference(room, path, destination) {
+        if (roomTarget(destination) === null && target(path, destination) === null) {
+            return ABSENT_TARGET;
+        }
+        const at = await located(room, path, destination);
+        if (at === null)
+            return UNREADABLE;
+        if (await locked(at.room))
+            return LOCKED_UNREADABLE;
+        const held = await recordAt(at.room);
+        if (held !== undefined &&
+            (await (await openLocal()).entries(held.key, 'visible', [at.path])).length > 0) {
+            return { kind: 'document', ...at };
+        }
+        const history = await readHistory(at.room, at.path);
+        if (history.kind === 'no-history' || history.kind === 'revision')
+            return ABSENT_TARGET;
+        if (history.kind !== 'history')
+            return history;
+        const [last] = history.revisions;
+        if (last === undefined)
+            return ABSENT_TARGET;
+        return history.deleted === true
+            ? { kind: 'deleted', ...at, revision: last }
+            : { kind: 'document', ...at };
+    }
+    async function cleanUp() {
+        const freed = await database.ask({ kind: 'opened.clean' });
+        return freed + ((await options.shell.cleanUp?.()) ?? 0);
+    }
+    async function declaredAction(name) {
+        for (const capability of (await (await openLocal()).facts()).capabilities) {
             for (const action of capability.actions ?? []) {
                 if (action.name === name)
                     return action;
@@ -839,28 +1452,33 @@ export function composeRuntime(options) {
         }
         return undefined;
     }
-    async function invokeAction(name, input) {
+    async function calledRooms(name, input) {
+        const member = (await declaredAction(name))?.room;
+        if (member === undefined || input === null || typeof input !== 'object')
+            return [];
+        const named = input[member];
+        return (Array.isArray(named) ? named : [named]).filter((room) => typeof room === 'string');
+    }
+    async function invokeAction(name, input, dispatching) {
         await ready;
         if (closed || refusal !== null)
-            return { kind: 'transport-uncertainty' };
-        if (declaredAction(name) === undefined)
-            return { kind: 'undeclared' };
+            return UNCERTAIN;
+        if ((await declaredAction(name)) === undefined)
+            return undeclared(name);
         try {
             await ensureAuthorization();
         }
         catch {
-            return { kind: 'transport-uncertainty' };
-        }
-        if (closed || authorization === undefined || refusal !== null) {
-            return { kind: 'transport-uncertainty' };
+            return UNCERTAIN;
         }
+        if (closed || authorization === undefined || refusal !== null)
+            return UNCERTAIN;
+        await dispatching?.();
         journal.record(`transfer action ${name}`);
         try {
             const result = await options.adapter.action(authorization, { name, input });
-            if (result.kind === 'action' && result.at !== undefined)
-                want(result.at);
             if (result.kind === 'scoped-refusal') {
-                const room = replicas.get(result.locator)?.confirmed.record;
+                const room = await recordAt(result.locator);
                 if (room !== undefined)
                     await scoped(result, room, await openLocal());
             }
@@ -869,111 +1487,165 @@ export function composeRuntime(options) {
             journal.record(`outcome action ${result.kind}`);
             if (result.kind === 'rejected')
                 journal.record(`refusal rejected ${result.code}`);
-            return result;
+            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));
-    }
-    function want({ locator, roomVersion }) {
-        if (reachedBy(locator, roomVersion))
-            return;
-        const held = wanted.get(locator);
-        if (held === undefined || options.adapter.reached(locator, roomVersion, held)) {
-            wanted.set(locator, roomVersion);
-        }
-    }
-    function reachOf(locator) {
-        let target = wanted.get(locator);
-        const versions = (replicas.get(locator)?.queue ?? []).flatMap((batch) => {
-            const accepted = pendings.get(batch.id)?.accepted;
-            return accepted === undefined ? [] : [accepted];
-        });
-        for (const version of versions) {
-            if (target === undefined || options.adapter.reached(locator, version, target)) {
-                target = version;
-            }
-        }
-        return target === undefined || reachedBy(locator, target) ? undefined : target;
-    }
-    async function pullRefresh(authorized, confirmed, minPosition) {
-        if (!continuing())
-            return unconfirmed;
+    async function readConversationHistory(request) {
+        await ready;
+        const stream = options.adapter.conversations;
+        if (closed || refusal !== null || stream?.history === undefined)
+            return UNCERTAIN;
+        journal.record('transfer conversation history');
         try {
-            const result = await refreshRoom(options.adapter, authorized, confirmed, continuing, minPosition);
-            const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
-            journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
-            return result;
+            const result = await stream.history(request);
+            if (result.kind === 'revoked-authorization')
+                await refuse('revoked-authorization');
+            journal.record(`outcome conversation history ${result.kind}`);
+            return calledResult(result);
         }
-        catch (error) {
-            journal.record(`transfer refresh ${confirmed.record.locator} transport-uncertainty`);
-            throw error;
+        catch {
+            journal.record('outcome conversation history transport-uncertainty');
+            return UNCERTAIN;
         }
     }
-    async function pullBootstrap(authorized, room) {
-        if (!continuing())
-            return unconfirmed;
+    function unsettled(result) {
+        return result.kind !== 'action' && result.retryable;
+    }
+    async function recoveredAction(name, input) {
+        const operation = operationOf(input);
+        if (operation === null)
+            return invokeAction(name, input);
+        const kept = async () => (await openLocal()).keepCall({ operation, name, input });
+        calling.add(operation);
         try {
-            const result = await bootstrapRoom(options.adapter, authorized, room, {
-                collection: modelOf(room.locator),
-                selection: modelOf(room.locator, 'typed-selection'),
-            }, continuing);
-            const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
-            journal.record(`transfer bootstrap ${room.locator} ${detail}`);
+            let result = await invokeAction(name, input, kept);
+            if (unsettled(result)) {
+                await recovery.attempt(`action ${operation}`, async () => {
+                    if (closed || refusal !== null)
+                        return 'done';
+                    if (!socket.isOpen())
+                        return 'again';
+                    result = await invokeAction(name, input, kept);
+                    return unsettled(result) ? 'again' : 'done';
+                }, { again: true });
+            }
+            if (!unsettled(result))
+                await (await openLocal()).dropCall(operation);
             return result;
         }
-        catch (error) {
-            journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
-            throw error;
+        finally {
+            calling.delete(operation);
         }
     }
-    async function advance(room, local, authorized) {
-        const held = replicas.get(room.locator);
-        if (held !== undefined) {
-            const refreshed = await pullRefresh(authorized, held.confirmed, reachOf(room.locator));
-            if (!continuing())
-                return unconfirmed;
-            if (refreshed.kind === 'still-current') {
-                if (sourceRefusals.has(room.locator))
-                    return unconfirmed;
-                if (unreadable.delete(room.locator)) {
-                    list(room, true);
-                    emitRooms();
-                }
-                return null;
+    async function resendCalls(signal) {
+        if (!socket.isOpen() || closed || stopping)
+            return 'done';
+        const local = await openLocal();
+        for (const held of await local.calls()) {
+            if (calling.has(held.operation))
+                continue;
+            if (closed || signal.aborted)
+                return 'done';
+            calling.add(held.operation);
+            try {
+                if (unsettled(await invokeAction(held.name, held.input)))
+                    return 'again';
+                await local.dropCall(held.operation);
             }
-            if (refreshed.kind === 'advanced') {
-                await publish(local, room, refreshed.confirmed);
-                return null;
+            finally {
+                calling.delete(held.operation);
             }
-            if (refreshed.kind !== 'beyond-horizon')
-                return refreshed;
         }
-        const bootstrapped = await pullBootstrap(authorized, room);
-        if (!continuing())
+        return 'done';
+    }
+    function continuing() {
+        return !closed && !discoveryPaused;
+    }
+    async function advance(room, local, authorized, running, unheld) {
+        const live = () => running() && !full;
+        if (!live())
             return unconfirmed;
+        const held = unheld === undefined ? await recordAt(room.locator) : undefined;
+        if (options.adapter.roomStream !== undefined &&
+            (held !== undefined || !store.installs.of(room.locator).beyondHorizon)) {
+            stale.delete(room.locator);
+            await name(room.locator);
+            return null;
+        }
+        const refresh = reads.refresh;
+        if (held !== undefined && refresh !== undefined) {
+            const refreshed = await store.ahead((hold) => refreshedRoom(room, local, authorized, held, live, hold, refresh));
+            if (refreshed === 'behind')
+                return advance(room, local, authorized, live);
+            if (refreshed !== 'beyond-horizon')
+                return refreshed;
+            if (reloadsDue.has(room.locator))
+                return unconfirmed;
+            replaced(store, [room.locator]);
+        }
+        const prior = held === undefined ? undefined : await recordAt(room.locator);
+        const from = standingAt(store, room.locator, prior);
+        const bootstrapped = await pullBootstrap(installer, authorized, room, local, live, prior, reads, unheld);
         if (bootstrapped.kind !== 'staged')
-            return bootstrapped;
-        await publish(local, room, bootstrapped.confirmed);
-        return null;
+            return live() ? bootstrapped : unconfirmed;
+        const landing = { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from };
+        if (await publish(installer, local, room, bootstrapped.record, landing, live)) {
+            return live() ? null : unconfirmed;
+        }
+        return (await reachedBy(installer, room.locator, bootstrapped.record.roomVersion))
+            ? null
+            : advance(room, local, authorized, live);
+    }
+    async function refreshedRoom(room, local, authorized, held, live, hold, refresh) {
+        const refreshed = await pullRefresh(installer, authorized, held, live, hold, refresh);
+        if (!live())
+            return unconfirmed;
+        if (refreshed.kind === 'still-current') {
+            stale.delete(room.locator);
+            if (unreadable.delete(room.locator)) {
+                scopedRefusals.delete(room.locator);
+                list(room, true);
+                emitRooms();
+            }
+            return null;
+        }
+        if (refreshed.kind === 'advanced') {
+            const landing = {
+                kind: 'refreshed',
+                from: refreshed.from,
+                remodelled: refreshed.remodelled,
+            };
+            if (!(await publish(installer, local, room, refreshed.record, landing, live))) {
+                const now = (await recordAt(room.locator))?.roomVersion;
+                const reached = now !== undefined &&
+                    options.adapter.reached(room.locator, now, refreshed.record.roomVersion);
+                return reached ? null : 'behind';
+            }
+            await retainModel(local, room, null);
+            return null;
+        }
+        return refreshed.kind === 'beyond-horizon' ? 'beyond-horizon' : refreshed;
     }
     async function withhold(withheld, room, local, progress) {
-        progress.complete = false;
+        if (withheld.kind === 'unconfirmed' || isFenced(room.locator))
+            return;
+        if (withheld.kind === 'not-ready') {
+            progress.complete = false;
+            askAgain(room.locator);
+            return;
+        }
+        stale.add(room.locator);
+        if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
+            const reset = withheld.kind === 'retryable-refusal' ? withheld.reset : undefined;
+            repairable.set(room.locator, reset);
+            repairLater(room.locator, reset === undefined ? { again: true } : { at: Date.parse(reset) });
+        }
+        else
+            repairable.delete(room.locator);
         if (withheld.kind === 'scoped-refusal') {
             await scoped(withheld, room, local);
         }
@@ -984,475 +1656,156 @@ export function composeRuntime(options) {
             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);
+            roomUnreadable(room);
         }
         else if (withheld.kind === 'revoked-authorization') {
             await refuse('revoked-authorization');
         }
     }
-    function refusedSource(room, { refusal }) {
-        sourceRefusals.set(room.locator, {
-            code: refusal.rule,
-            fields: {
-                file: refusal.file,
-                ...(refusal.location === undefined ? {} : { location: refusal.location }),
-                ...(refusal.referrers === undefined ? {} : { referrers: refusal.referrers }),
-            },
-        });
-        declarationRefusals.delete(room.locator);
+    function roomUnreadable(room) {
         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: { kind: 'expired' } };
-        return { batch, returned: { kind: result.kind, code: result.code, fields: result.fields } };
     }
-    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 recordAccepted(room, local, submitted, accepted) {
+    function askAgain(locator) {
+        const held = unready.get(locator) ?? { tries: 0, timer: null };
+        unready.set(locator, held);
+        if (held.timer !== null)
+            return;
+        const wait = NOT_READY_MS[Math.min(held.tries, NOT_READY_MS.length - 1)];
+        held.tries += 1;
+        held.timer = setTimeout(() => {
+            held.timer = null;
+            const room = discovered.get(locator);
+            const unstreamed = options.adapter.roomStream === undefined;
+            if (closed || stopping || (!unstreamed && !socket.isOpen()) || room === undefined)
+                return;
+            const progress = { complete: true, reachable: true };
+            void openLocal()
+                .then((local) => roomTask(locator, (live) => loadRoom(room, local, progress, live)))
+                .then(() => rest(progress), () => undefined);
+        }, wait);
+    }
+    function readied(locator) {
+        const held = unready.get(locator);
+        if (held === undefined)
+            return;
+        if (held.timer !== null)
+            clearTimeout(held.timer);
+        unready.delete(locator);
+    }
+    function unreadied() {
+        for (const locator of [...unready.keys()])
+            readied(locator);
+    }
+    function declaredAsHeld(held, room) {
+        return (held === undefined ||
+            (JSON.stringify(held.operations) === JSON.stringify(room.operations) &&
+                JSON.stringify(held.replica) === JSON.stringify(room.replica) &&
+                JSON.stringify(held.providerOwnedPaths) === JSON.stringify(room.providerOwnedPaths) &&
+                JSON.stringify(held.typedSelection) === JSON.stringify(room.typedSelection ?? null)));
+    }
+    async function keepNaming(local, room) {
+        const held = await recordAt(room.locator);
+        if (held === undefined || (held.name === room.name && held.handle === room.handle))
+            return;
         await exclusive(async () => {
             if (!continuing())
                 return;
-            const current = replicas.get(room.locator);
-            if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
-                return;
-            }
-            const state = pendings.get(submitted.id);
-            if (state === undefined)
+            const current = await recordAt(room.locator);
+            if (current === undefined)
                 return;
-            await local.accept(room.locator, submitted.id, accepted.roomVersion);
-            pendings.set(submitted.id, { ...state, accepted: accepted.roomVersion });
-            logAccepted(room.locator, submitted, accepted);
-            emitQueue(room.locator);
-        });
-    }
-    async function commitAccept(room, local, submitted, accepted, base, overlay) {
-        if (!continuing())
-            return unconfirmed;
-        const current = replicas.get(room.locator);
-        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'),
-        }, base);
-        const applied = overlay && retainedBase.kind === 'staged'
-            ? applyReturned(retainedBase.confirmed, accepted.documents, accepted.revisions, accepted.removals, accepted.roomVersion)
-            : retainedBase;
-        if (applied.kind !== 'staged')
-            return applied;
-        const set = await settle(local, room.locator, current, applied.confirmed, remaining, {
-            room: true,
+            const record = { ...current, name: room.name, handle: room.handle };
+            await local.commit({
+                rooms: [
+                    {
+                        locator: room.locator,
+                        key: record.key,
+                        record: storedRecord(record),
+                        composed: composedOf(composed(record)),
+                    },
+                ],
+            });
+            emitRooms();
         });
-        unreadable.delete(room.locator);
-        sourceRefusals.delete(room.locator);
-        declarationRefusals.delete(room.locator);
-        list(room, true);
-        publishChangeSet(set);
-        moveTo({ ...status, ...attention() });
-        return null;
     }
-    async function accepting(room, local, submitted, accepted, pulled, fresh) {
-        const roomVersion = pulled.record.roomVersion;
-        if (options.adapter.reached(room.locator, roomVersion, accepted.roomVersion)) {
-            return committed(room, local, submitted, accepted, pulled, roomVersion === accepted.roomVersion);
-        }
-        if (fresh && continuing())
-            await publish(local, room, pulled);
-        return false;
+    async function modelNow(locator) {
+        return (await recordAt(locator))?.model ?? unheldModels.get(locator) ?? NO_MODEL;
     }
-    async function committed(room, local, submitted, accepted, base, overlay) {
-        const failed = await exclusive(() => commitAccept(room, local, submitted, accepted, base, overlay));
-        if (failed === null)
-            return true;
-        if (failed.kind === 'refused' && continuing())
-            refusedSource(room, failed);
-        return false;
-    }
-    async function submitRoom(room, local, authorized, progress) {
-        while (continuing() && authorization !== undefined) {
-            const replica = replicas.get(room.locator);
-            const head = replica?.queue[0];
-            if (replica === undefined || head === undefined)
-                return;
-            if (pendings.get(head.id)?.accepted !== undefined) {
-                progress.complete = false;
-                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)
-                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;
-            try {
-                result = await options.adapter.mutate(authorized, {
-                    locator: room.locator,
-                    changeBatch: head,
-                    ...(state?.upload === undefined ? {} : { upload: state.upload }),
-                }, (upload) => exclusive(() => keepUpload(local, room.locator, head.id, upload)));
-            }
-            catch {
-                progress.complete = false;
-                if (continuing())
-                    progress.reachable = false;
-                return;
-            }
-            if (!continuing())
-                return;
-            if (result.kind === 'transport-uncertainty') {
-                progress.complete = false;
-                progress.reachable = false;
-                return;
-            }
-            if (result.kind === 'room-not-readable') {
-                progress.complete = false;
-                unreadable.add(room.locator);
-                list(room, false);
-                emitRooms();
-                return;
-            }
-            if (result.kind === 'revoked-authorization') {
-                await refuse('revoked-authorization');
-                return;
-            }
-            if (result.kind === 'scoped-refusal') {
-                await scoped(result, room, local);
-                progress.complete = false;
-                return;
-            }
-            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;
-            }
-            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);
-                }
-                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') {
-                const reset = result.reset;
-                progress.complete = false;
-                await exclusive(() => mark(local, room.locator, head.id, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
-                return;
-            }
-            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)
-                            ? { ...left, returned: null }
-                            : left,
-                    });
-                    publishChangeSet(set);
-                    moveTo({ ...status, ...attention() });
-                });
-                if (result.kind === 'expired')
-                    continue;
-                const withheld = await advance(room, local, authorized);
-                if (withheld !== null)
-                    return withhold(withheld, room, local, progress);
-                continue;
-            }
-            await recordAccepted(room, local, head, result);
-            const from = replicas.get(room.locator)?.confirmed;
-            if (from === undefined)
-                return;
-            const pulled = await pullRefresh(authorized, from, reachOf(room.locator));
-            if (!continuing())
-                return;
-            if (pulled.kind === 'revoked-authorization') {
-                await refuse('revoked-authorization');
-                return;
-            }
-            if (pulled.kind === 'scoped-refusal') {
-                await scoped(pulled, room, local);
-                progress.complete = false;
-                return;
-            }
-            if (pulled.kind === 'still-current' || pulled.kind === 'advanced') {
-                const fresh = pulled.kind === 'advanced';
-                if (!(await accepting(room, local, head, result, fresh ? pulled.confirmed : from, fresh))) {
-                    progress.complete = false;
-                    return;
-                }
-                continue;
-            }
-            if (pulled.kind === 'beyond-horizon') {
-                const bootstrapped = await pullBootstrap(authorized, room);
-                if (!continuing())
-                    return;
-                if (bootstrapped.kind === 'revoked-authorization') {
-                    await refuse('revoked-authorization');
-                    return;
-                }
-                if (bootstrapped.kind === 'scoped-refusal') {
-                    await scoped(bootstrapped, room, local);
-                    progress.complete = false;
-                    return;
-                }
-                if (bootstrapped.kind === 'staged') {
-                    if (!(await accepting(room, local, head, result, bootstrapped.confirmed, true))) {
-                        progress.complete = false;
-                        return;
-                    }
-                    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();
-                }
-                else if (bootstrapped.kind === 'refused') {
-                    refusedSource(room, bootstrapped);
-                }
-                return;
-            }
-            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();
-            }
-            else if (pulled.kind === 'retryable-refusal') {
-                journal.record(`refusal ${pulled.kind} ${pulled.code}`);
-            }
-            else if (pulled.kind === 'refused') {
-                refusedSource(room, pulled);
-            }
-            return;
-        }
-        return;
-    }
-    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))))
+    async function retainModel(local, room, given) {
+        const held = await recordAt(room.locator);
+        const previous = held?.model ?? unheldModels.get(room.locator) ?? NO_MODEL;
+        const next = given ?? previous;
+        if (JSON.stringify(previous) === JSON.stringify(next) && declaredAsHeld(held, room))
             return;
-        if (next.status === 'unavailable') {
-            invalidModels.add(key);
-            liveModels.delete(key);
-        }
         await exclusive(async () => {
             if (!continuing())
                 return;
-            if (next.status !== 'unavailable' && epoch !== (modelEpoch.get(key) ?? 0))
-                return;
-            const held = replicas.get(room.locator);
-            if (held !== undefined) {
-                const declared = {
-                    ...held.confirmed.record,
+            const work = await workOf(room.locator);
+            const current = work.replica;
+            let changed = null;
+            if (current !== undefined) {
+                const record = {
+                    ...current.record,
+                    name: room.name,
+                    handle: room.handle,
                     operations: room.operations,
                     replica: room.replica,
-                    attachedModel: room.attachedModel,
+                    providerOwnedPaths: room.providerOwnedPaths,
                     typedSelection: room.typedSelection ?? null,
-                    ...(attached === 'collection' ? { model: next } : { selectionModel: next }),
+                    model: next,
                 };
-                const reclassified = sameMembership(declared, held.confirmed.record)
-                    ? readConfirmed(declared, held.confirmed)
-                    : readReclassified(declared, held.confirmed);
-                const record = reclassified.kind === 'staged'
-                    ? declared
-                    : {
-                        ...declared,
-                        typedSelection: held.confirmed.record.typedSelection,
-                    };
-                const read = reclassified.kind === 'deferred' ? readConfirmed(record, held.confirmed) : reclassified;
-                await local.write({
-                    next: record,
-                    previous: held.confirmed.record,
-                    queue: held.queue,
+                const confirmedLayer = await sliceAt(store, record, 'confirmed', current.queue, current.overlaid);
+                const replayedLayer = await replayed(store, record, confirmedLayer, current.queue);
+                const diff = await overlayDiff(record, current, replayedLayer.visible, replayedLayer.touched);
+                const answer = await local.commit({
+                    rooms: [
+                        {
+                            locator: room.locator,
+                            key: record.key,
+                            record: storedRecord(record),
+                            roots: record.typedSelection?.roots ?? [],
+                            composed: composedOf(composed(record)),
+                            overlay: diff.overlay,
+                        },
+                    ],
+                });
+                preparedAfter(saver, room.locator, answer);
+                changed = changeSet(room.locator, {
+                    documents: answer.changed[room.locator] ?? [],
+                    room: true,
                 });
-                if (read.kind === 'staged') {
-                    replicas.set(room.locator, replicaOf(read.confirmed, held.queue, rewriting(), 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') {
-                liveModels.set(key, JSON.stringify(next.snapshot));
-                invalidModels.delete(key);
             }
+            else
+                unheldModels.set(room.locator, next);
             list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
-            if (held === undefined)
+            if (changed === null)
                 emitRooms();
             else
-                publishChangeSet(changeSet(room.locator, held, replicas.get(room.locator) ?? null, { room: true }));
+                publishChangeSet(changed);
         });
     }
-    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);
-            if (discoveryPaused)
-                return;
-        }
-        const epoch = modelEpoch.get(key) ?? 0;
-        let answer;
-        try {
-            answer = await options.adapter.model(authorized, selection === null
-                ? { locator: room.locator, attached: 'collection', model: declared }
-                : {
-                    locator: room.locator,
-                    attached: 'typed-selection',
-                    roots: selection.roots,
-                    model: declared,
-                });
-        }
-        catch {
-            answer = { kind: 'transport-uncertainty' };
-        }
-        if (discoveryPaused || epoch !== (modelEpoch.get(key) ?? 0))
-            return;
-        if (answer.kind === 'revoked-authorization') {
-            await 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) &&
-            previous.snapshot.schema !== answer.snapshot.schema) {
-            await retainModel(local, room, attached, { status: 'unavailable', reason: 'invalid' });
+    async function scoped(result, room, local) {
+        if (result.scope === 'content' && !result.retryable) {
+            journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
+            await loseRooms([room.locator]);
             return;
         }
-        const verified = answer.snapshot.schema === null ? EMPTY_SCHEMA : verify(answer.snapshot.schema);
-        if (verified.verdict === 'refuse') {
-            const where = verified.location === undefined ? '' : ` ${verified.location}`;
-            journal.record(`model invalid ${room.locator} ${attached} ${answer.snapshot.identity} ${verified.rule}${where}`);
-        }
-        await retainModel(local, room, attached, verified.verdict === 'accept'
-            ? {
-                status: 'current',
-                snapshot: structuredClone(answer.snapshot),
-                verifiedWith: MD_MODEL,
-                types: verified.model.types,
-            }
-            : { status: 'unavailable', reason: 'invalid' });
-    }
-    async function scoped(result, room, local) {
-        scopedRefusals.set(room.locator, { code: result.code, fields: result.fields });
+        scopedRefusals.set(room.locator, {
+            code: result.code,
+            fields: result.fields,
+            retryable: result.retryable,
+        });
         let scopedAway = room;
         if (result.scope === 'model')
-            await retainModel(local, room, 'collection', {
+            await retainModel(local, room, {
                 status: 'unavailable',
                 reason: 'not-readable',
             });
         else if (result.scope !== 'operation') {
             unreadable.add(room.locator);
-            scopedAway = {
-                ...room,
-                replica: { ...room.replica, admission: 'unavailable' },
-                operations: {
-                    ...room.operations,
-                    ...(result.scope === 'content' ? { read: [] } : {}),
-                    ...(result.scope === 'sync' ? { sync: [] } : {}),
-                },
-            };
-            await retainModel(local, scopedAway, 'collection', modelOf(room.locator));
+            scopedAway = { ...room, replica: { ...room.replica, admission: 'unavailable' } };
+            await retainModel(local, scopedAway, null);
         }
         if (!continuing())
             return;
@@ -1460,91 +1813,194 @@ export function composeRuntime(options) {
         emitRooms();
         journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
     }
-    async function synchronize(discovered, local, progress) {
-        const prepared = await Promise.allSettled(discovered.map((room) => prepareRoom(room, local, progress)));
-        const ready = discovered.filter((_, index) => {
+    async function name(locator) {
+        const room = discovered.get(locator);
+        if (!socket.streamed || room === undefined || !socket.isOpen() || !socket.isHanded())
+            return;
+        const [held] = await heldRooms([room]);
+        if (held === undefined || !socket.isOpen() || !socket.isHanded())
+            return;
+        socket.name(held);
+    }
+    async function heldRooms(listed) {
+        const stored = await storedRooms(listed.map((room) => room.locator));
+        return listed.flatMap((room) => {
+            const record = stored.get(room.locator)?.record;
+            if (record === undefined) {
+                return room.replica.admission === 'admitted'
+                    ? [{ locator: room.locator, roomVersion: null }]
+                    : [];
+            }
+            if (record.replica.selection !== room.replica.selection)
+                return [];
+            return [{ locator: room.locator, roomVersion: record.roomVersion }];
+        });
+    }
+    async function synchronize(listed, local, progress, attempt, live) {
+        const heldNow = await storedRooms(listed.map(({ locator }) => locator));
+        const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(room, local, progress, heldNow.get(room.locator)?.record)));
+        if (!live())
+            return;
+        const ready = listed.filter((_, index) => {
             const outcome = prepared[index];
             return outcome?.status === 'fulfilled' && outcome.value;
         });
-        const rooms = await Promise.allSettled(ready.map((room) => synchronizeRoom(room, local, progress)));
-        const failed = [...prepared, ...rooms].find((room) => room.status === 'rejected');
+        const held = await heldRooms(ready);
+        if (!live())
+            return;
+        if (attempt === 'opened') {
+            socket.hand(held);
+        }
+        const kept = attempt === 'unstreamed'
+            ? new Set()
+            : new Set((await storedRooms(ready.map(({ locator }) => locator))).keys());
+        for (const room of ready) {
+            if (attempt === 'opened' || kept.has(room.locator)) {
+                if (attempt === 'authorized')
+                    await name(room.locator);
+                continue;
+            }
+            void roomTask(room.locator, (live) => loadRoom(room, local, progress, live)).then(() => rest(progress));
+        }
+        const failed = prepared.find((room) => room.status === 'rejected');
         if (failed !== undefined)
             throw failed.reason;
     }
-    async function prepareRoom(room, local, progress) {
+    async function prepareRoom(room, local, progress, prior) {
         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);
+            listHeld(room.locator);
             emitRooms();
             journal.record(`selection changed ${room.locator}`);
             progress.complete = false;
             return false;
         }
-        const selection = room.typedSelection;
-        await Promise.all([
-            acquireModel(local, room, authorization, null),
-            ...(selection === undefined ? [] : [acquireModel(local, room, authorization, selection)]),
-        ]);
-        if (discoveryPaused || authorization === undefined)
-            return false;
-        if (room.replica.admission !== 'admitted') {
-            if (replicas.has(room.locator))
-                progress.complete = false;
-            return false;
+        if (prior !== undefined && !declaredAsHeld(prior, room))
+            await retainModel(local, room, null);
+        if (prior !== undefined && (prior.name !== room.name || prior.handle !== room.handle)) {
+            await keepNaming(local, room);
         }
-        const held = replicas.get(room.locator);
-        if (held !== undefined && held.confirmed.record.replica.selection !== room.replica.selection) {
-            progress.complete = false;
+        if (discoveryPaused || authorization === undefined)
             return false;
-        }
-        return true;
+        return room.replica.admission === 'admitted';
     }
-    async function synchronizeRoom(room, local, progress) {
-        if (discoveryPaused || authorization === undefined)
+    async function caughtUp(room, local, progress, live) {
+        if (options.adapter.roomStream !== undefined || authorization === undefined)
+            return;
+        if (!live() || !(await behind(installer, room)))
+            return;
+        const withheld = await advance(room, local, authorization, live);
+        if (withheld !== null)
+            await withhold(withheld, room, local, progress);
+    }
+    function revoked(model) {
+        return model?.status === 'unavailable' && model.reason === 'revoked';
+    }
+    async function loadRoom(room, local, progress, live, unheld) {
+        if (!live() || authorization === undefined)
             return;
-        const withheld = await advance(room, local, authorization);
+        const prior = unheld === undefined ? await recordAt(room.locator) : undefined;
+        if (prior !== undefined) {
+            if (!(await prepareRoom(room, local, progress, prior)))
+                return;
+            if (revoked(prior.model)) {
+                await reload(room, local, progress, live);
+                return;
+            }
+        }
+        const withheld = await advance(room, local, authorization, live, unheld);
         if (withheld !== null) {
             await withhold(withheld, room, local, progress);
             return;
         }
-        await submitRoom(room, local, authorization, progress);
+        await caughtUp(room, local, progress, live);
     }
-    async function cycle(local, progress) {
-        if (closed || authorization === undefined) {
-            notifyReady();
-            return;
+    async function reload(room, local, progress, live) {
+        try {
+            if (live())
+                reloadsDue.delete(room.locator);
+            if (!live() || authorization === undefined)
+                return;
+            const prior = await recordAt(room.locator);
+            const from = standingAt(store, room.locator, prior);
+            const bootstrapped = await pullBootstrap(installer, authorization, room, local, live, prior);
+            if (bootstrapped.kind !== 'staged') {
+                if (live())
+                    await withhold(bootstrapped, room, local, progress);
+                return;
+            }
+            await publish(installer, local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
+            await caughtUp(room, local, progress, live);
+        }
+        finally {
+            caughtUpTo(installer, room.locator);
         }
-        moveTo(transferring(status));
-        let result;
+    }
+    async function asked(authorized) {
         try {
-            result = await options.adapter.discover(authorization);
+            return (await options.adapter.discover?.(authorized)) ?? { kind: 'transport-uncertainty' };
         }
         catch {
-            result = { kind: 'transport-uncertainty' };
+            return { kind: 'transport-uncertainty' };
         }
-        if (closed) {
+    }
+    function malformed(listed) {
+        for (const room of listed) {
+            if (room.operations === undefined ||
+                !['write', 'erase'].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) ||
+                !['locked', 'open'].includes(room.replica.offline)) {
+                return `invalid model or replica declaration ${room.locator}`;
+            }
+            if (!declaredSelection(room))
+                return `invalid typed selection declaration ${room.locator}`;
+        }
+        return null;
+    }
+    async function signIn(local, signedIn) {
+        if (JSON.stringify(signedIn) === JSON.stringify((await local.facts()).member))
+            return;
+        await local.fact('member', signedIn);
+        emitMember(signedIn);
+    }
+    async function discoverRooms(local, progress, attempt, live, found) {
+        if (closed || authorization === undefined) {
+            notifyReady();
+            return;
+        }
+        moveTo(transferring());
+        discoveries += 1;
+        const started = discoveries;
+        const result = found ?? (await asked(authorization));
+        if (result.kind === 'discovery')
+            roomsNamed = true;
+        if (!live()) {
+            progress.complete = false;
             notifyReady();
             return;
         }
         journal.record(`connection discover ${result.kind}`);
         if (result.kind === 'transport-uncertainty') {
-            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')));
-                }
-            }
+            await cachedModels(local);
             progress.reachable = false;
+            progress.complete = false;
             notifyReady();
             return;
         }
         if (result.kind === 'contract-unavailable') {
             journal.record(`connection contract unavailable ${result.code}`);
-            await refuse('missing-required-guarantee', { code: result.code, fields: result.fields });
+            await refuse('missing-required-guarantee', {
+                code: result.code,
+                fields: result.fields,
+                retryable: result.retryable,
+            });
             notifyReady();
             return;
         }
@@ -1553,146 +2009,572 @@ export function composeRuntime(options) {
             notifyReady();
             return;
         }
-        if (!result.supportedVersions.includes(ROOM_CONTRACT_VERSION)) {
-            await refuse('no-matching-version');
+        const invalid = malformed(result.rooms);
+        if (invalid !== null) {
+            journal.record(invalid);
+            await refuse('missing-required-guarantee');
             notifyReady();
             return;
         }
-        if (result.mdModel.identity !== MD_MODEL.identity ||
-            result.mdModel.version !== MD_MODEL.version) {
-            await refuse('md-model-version-mismatch');
-            notifyReady();
+        if (refusal !== null) {
+            refusal = null;
+            emitRefusal();
+        }
+        const held = await local.facts();
+        if (JSON.stringify(result.providerLimits) !== JSON.stringify(held.providerLimits) ||
+            JSON.stringify(result.capabilities) !== JSON.stringify(held.capabilities)) {
+            await local.fact('providerLimits', result.providerLimits);
+            await local.fact('capabilities', result.capabilities);
+        }
+        notifyReady();
+        await signIn(local, result.member ?? null);
+        await synchronize(await applyDiscovery(result.rooms, started), local, progress, attempt, live);
+    }
+    async function ensureAuthorization() {
+        if (authorization !== undefined)
             return;
+        try {
+            authorization = await options.adapter.authorize();
+            journal.record('connection authorize');
         }
-        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) ||
-                !declaredIdentity(room.attachedModel)) {
-                journal.record(`invalid model or replica declaration ${room.locator}`);
-                await refuse('missing-required-guarantee');
+        catch (error) {
+            journal.record('connection authorize transport-uncertainty');
+            throw error;
+        }
+    }
+    async function admittedRead(work) {
+        while (roomReads.free === 0) {
+            await new Promise((admit) => roomReads.waiting.push(admit));
+        }
+        roomReads.free -= 1;
+        try {
+            await work();
+        }
+        finally {
+            roomReads.free += 1;
+            roomReads.waiting.shift()?.();
+        }
+    }
+    function inRoom(locator, work) {
+        roomWork += 1;
+        const ran = (roomLanes.get(locator) ?? Promise.resolve()).then(async () => {
+            try {
+                return await work(continuing);
+            }
+            finally {
+                roomWork -= 1;
+            }
+        });
+        const chain = ran.then(() => undefined, () => undefined);
+        roomLanes.set(locator, chain);
+        working.add(chain);
+        void chain.finally(() => {
+            working.delete(chain);
+            if (roomLanes.get(locator) === chain)
+                roomLanes.delete(locator);
+        });
+        return ran;
+    }
+    function roomTask(locator, work) {
+        if (stopping)
+            return Promise.resolve();
+        return inRoom(locator, (live) => admittedRead(() => work(live))).catch(() => undefined);
+    }
+    function advanced(room, local, authorized) {
+        return inRoom(room.locator, (live) => advance(room, local, authorized, live));
+    }
+    function task(lane, work) {
+        if (stopping)
+            return Promise.resolve();
+        const held = lanes.get(lane);
+        const opened = socket.generation();
+        const current = held?.generation === opened ? held : { generation: opened, chain: Promise.resolve() };
+        const turn = current.generation;
+        const live = () => turn === socket.generation() && continuing();
+        const run = current.chain.then(() => work(live)).catch(() => undefined);
+        current.chain = run;
+        lanes.set(lane, current);
+        working.add(run);
+        void run.finally(() => working.delete(run));
+        return run;
+    }
+    function sync(attempt, found) {
+        return task(OPENING_LANE, async (live) => {
+            if (!live()) {
+                readyFromStore();
+                return;
+            }
+            const progress = { complete: true, reachable: true };
+            underway = attempt === 'opened' ? progress : null;
+            if (attempt === 'opened')
+                streamed = progress;
+            complete = false;
+            recorded = false;
+            moveTo(transferring());
+            try {
+                const local = await openLocal();
+                if (!live())
+                    return;
+                await ensureAuthorization();
+                if (!live())
+                    return;
+                await discoverRooms(local, progress, attempt, live, found);
+            }
+            catch {
+                progress.complete = false;
+                if (attempt === 'opened' && !socket.isHanded())
+                    progress.reachable = false;
+            }
+            finally {
                 notifyReady();
+            }
+            if (!live())
+                return;
+            if (attempt !== 'opened') {
+                await finishOpening(progress, live);
                 return;
             }
-            if (!declaredSelection(room)) {
-                journal.record(`invalid typed selection declaration ${room.locator}`);
-                await refuse('missing-required-guarantee');
-                notifyReady();
+            if (socket.isHanded() || closed || progress.reachable)
+                return;
+            underway = null;
+            await rest(progress, live);
+        });
+    }
+    function resynchronize() {
+        return task(OPENING_LANE, async (live) => {
+            if (!live() || !socket.isAnnounced())
                 return;
+            const progress = { complete: true, reachable: true };
+            moveTo(transferring());
+            try {
+                const local = await openLocal();
+                if (!live())
+                    return;
+                await synchronize([...discovered.values()], local, progress, 'unstreamed', live);
             }
-        }
-        const declared = new Set(result.capabilities.map((capability) => capability.name));
-        for (const required of options.requiredGuarantees) {
-            if (!knownCapabilities.has(required) || !declared.has(required)) {
-                await refuse('missing-required-guarantee');
-                notifyReady();
+            catch {
+                progress.complete = false;
+            }
+            if (live())
+                await finishOpening(progress, live);
+        });
+    }
+    function countAuthorityChange() {
+        authorityChanges += 1;
+        for (const listener of authorityChangeListeners)
+            listener(authorityChanges);
+        lastAnswers.again();
+    }
+    function changeAuthority(change) {
+        return task(OPENING_LANE, async (live) => {
+            if (!live() || !socket.isAnnounced())
                 return;
+            countAuthorityChange();
+            const progress = { complete: true, reachable: true };
+            moveTo(transferring());
+            try {
+                const local = await openLocal();
+                if (!live())
+                    return;
+                const invalid = malformed(change.rooms);
+                if (invalid !== null) {
+                    journal.record(invalid);
+                    await refuse('missing-required-guarantee');
+                    return;
+                }
+                if (change.member !== undefined)
+                    await signIn(local, change.member);
+                discoveries += 1;
+                const listed = await applyDiscovery(change.rooms, discoveries, change.left);
+                await synchronize(listed, local, progress, 'authorized', live);
             }
-        }
-        if (refusal !== null) {
-            refusal = null;
-            emitRefusal();
-        }
-        const previousCapabilities = capabilities;
-        capabilities = result.capabilities;
+            catch {
+                progress.complete = false;
+            }
+            if (!live())
+                return;
+            if (!progress.complete)
+                complete = false;
+            await rest(progress, live);
+        });
+    }
+    function closedSocket(revoked, lost, opened) {
         notifyReady();
-        if (declared.has('room-version-notifications'))
-            observeRoomVersions();
-        if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits) ||
-            JSON.stringify(result.capabilities) !== JSON.stringify(previousCapabilities)) {
-            limits = result.providerLimits;
-            await local.declare(limits, capabilities);
-        }
-        await applyDiscovery(result.rooms, local);
-        handSelected(result.rooms
-            .filter((room) => room.replica.admission === 'admitted')
-            .map((room) => room.locator)
-            .sort());
-        progress.complete = true;
-        await synchronize(result.rooms, local, progress);
-        if (closed || discoveryPaused)
+        unreadied();
+        connectionLost();
+        if (lost)
+            conversations.lost();
+        if (revoked) {
+            void refuse('revoked-authorization');
             return;
-        await conversations.reconcile();
-        if (status.providerUnreachable)
-            conversations.reconnected();
-        await conversations.catchUp(progress);
+        }
+        complete = false;
+        if (streamed !== null)
+            streamed.complete = false;
+        moveTo({
+            ...status,
+            state: status.state === 'synced' ? 'syncing' : status.state,
+            providerUnreachable: status.providerUnreachable || (!opened && lost),
+        });
+        void closing(opened);
     }
-    async function ensureAuthorization() {
-        if (authorization !== undefined)
-            return;
+    function closing(opened) {
+        return task(OPENING_LANE, async (live) => {
+            if (!live())
+                return;
+            const local = await openLocal();
+            if (!opened && !socket.isOpen())
+                await cachedModels(local);
+            await rest(null, live);
+        });
+    }
+    async function cachedModels(local) {
+        const held = await storedRooms();
+        await settleModels(listedLocators(held).flatMap((locator) => {
+            const room = discovered.get(locator) ?? declarationOf(locator, held.get(locator))?.room;
+            return room === undefined ? [] : [room];
+        }), 'cached', local);
+    }
+    function caughtUpRooms(expired) {
+        const progress = underway;
+        underway = null;
+        socket.named();
+        const cycle = progress ?? { complete: true, reachable: true };
+        replaced(store, expired);
+        const installing = store.installs.underway();
+        const held = progress === null ? storedRooms(expired) : storedRooms();
+        const reloading = progress === null
+            ? Promise.resolve([])
+            : held.then((stored) => owedReloads(expired, stored));
+        const replacing = Promise.all([held, reloading]).then(([stored, owed]) => reloadNow((room) => expired.includes(room.locator) || owed.includes(room.locator), cycle, stored, installing));
+        return task(OPENING_LANE, async (live) => {
+            if (!live())
+                return;
+            if (progress === null) {
+                await replacing;
+                await rest(cycle, live);
+                return;
+            }
+            try {
+                const local = await openLocal();
+                await replacing;
+                if (progress.reachable) {
+                    const stored = await held;
+                    const owed = await reloading;
+                    await settleModels([...discovered.values()].filter((room) => stored.has(room.locator) &&
+                        !expired.includes(room.locator) &&
+                        !owed.includes(room.locator)), 'current', local);
+                }
+            }
+            catch {
+                progress.complete = false;
+                progress.reachable = false;
+            }
+            if (live())
+                await finishOpening(progress, live);
+        });
+    }
+    function owedReloads(expired, held) {
+        const reloading = [...discovered.values()]
+            .filter((room) => !expired.includes(room.locator) && revoked(held.get(room.locator)?.record.model))
+            .map((room) => room.locator);
+        for (const locator of reloading)
+            catching(store, locator);
+        recoverReads();
+        return reloading;
+    }
+    async function reloadNow(replaced, progress, held, installing) {
+        const reloaded = [...discovered.values()].filter((room) => held.has(room.locator) && !installing.has(room.locator) && replaced(room));
+        const acquired = [...discovered.values()].filter((room) => (!held.has(room.locator) || installing.has(room.locator)) &&
+            room.replica.admission === 'admitted' &&
+            replaced(room));
+        for (const room of reloaded)
+            reloadsDue.add(room.locator);
         try {
-            authorization = await options.adapter.authorize();
-            journal.record('connection authorize');
+            const local = await openLocal();
+            const kept = acquired.length === 0 ? new Set() : (await local.held()).staged;
+            for (const room of reloaded) {
+                void roomTask(room.locator, (live) => reload(room, local, progress, live)).then(() => rest(progress));
+            }
+            for (const room of acquired) {
+                const unheld = installing.has(room.locator)
+                    ? undefined
+                    : { staged: kept.has(room.locator) };
+                void roomTask(room.locator, (live) => loadRoom(room, local, progress, live, unheld)).then(() => rest(progress));
+            }
         }
-        catch (error) {
-            journal.record('connection authorize transport-uncertainty');
-            throw error;
+        catch {
+            for (const room of reloaded)
+                reloadsDue.delete(room.locator);
+            progress.reachable = false;
         }
     }
-    async function connect() {
-        if (closed || stopping || discoveryPaused) {
-            notifyReady();
-            return;
+    async function settleModels(held, status, local) {
+        const owed = (model) => model.status !== 'unavailable' && model.status !== status;
+        const declaredAnew = await exclusive(async () => {
+            if (!continuing())
+                return [];
+            const stored = await storedRooms(held.map(({ locator }) => locator));
+            const unchanged = held.filter((room) => {
+                const record = stored.get(room.locator)?.record;
+                return (owed(record?.model ?? unheldModels.get(room.locator) ?? NO_MODEL) &&
+                    declaredAsHeld(record, room));
+            });
+            const records = unchanged.flatMap((room) => {
+                const record = stored.get(room.locator)?.record;
+                return record === undefined
+                    ? []
+                    : [{ ...record, model: { ...record.model, status } }];
+            });
+            if (records.length > 0) {
+                try {
+                    await local.commit({
+                        rooms: records.map((record) => ({
+                            locator: record.locator,
+                            key: record.key,
+                            record: storedRecord(record),
+                            composed: composedOf(composed(record)),
+                        })),
+                    });
+                }
+                catch {
+                    journal.record(`model ${status} persistence failed`);
+                }
+            }
+            for (const room of unchanged) {
+                const unheld = unheldModels.get(room.locator);
+                if (!stored.has(room.locator) && unheld !== undefined) {
+                    unheldModels.set(room.locator, { ...unheld, status });
+                }
+                list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
+            }
+            if (unchanged.length > 0)
+                emitRooms();
+            return held.filter((room) => {
+                const record = stored.get(room.locator)?.record;
+                return (!unchanged.includes(room) &&
+                    owed(record?.model ?? unheldModels.get(room.locator) ?? NO_MODEL));
+            });
+        });
+        for (const room of declaredAnew) {
+            const model = await modelNow(room.locator);
+            if (owed(model))
+                await retainModel(local, room, { ...model, status });
         }
-        startTimer();
-        const progress = { complete: false, reachable: true };
-        let completedAt = new Date().toISOString();
+    }
+    function repairLater(locator, when) {
+        if (!socket.isOpen() || repairing.has(locator))
+            return;
+        void recovery.attempt(`repair ${locator}`, (signal) => repairPass(locator, signal), when);
+    }
+    async function repairPass(locator, signal) {
+        const room = discovered.get(locator);
+        if (!socket.isOpen() || closed || stopping || discoveryPaused || !stale.has(locator))
+            return 'done';
+        if (room === undefined || room.replica.admission !== 'admitted')
+            return 'done';
+        const progress = { complete: true, reachable: true };
+        repairing.add(locator);
         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 roomTask(locator, async (live) => {
+                if (!live() || authorization === undefined)
+                    return;
+                const withheld = await advance(room, local, authorization, live);
+                if (withheld !== null && live())
+                    await withhold(withheld, room, local, progress);
+            });
         }
         catch {
-            progress.complete = false;
-            notifyReady();
-            return;
+            stale.add(locator);
+            progress.reachable = false;
         }
         finally {
-            notifyReady();
-            moveTo(settled(status, progress, completedAt, pending(), attention()));
+            repairing.delete(locator);
+        }
+        if (signal.aborted)
+            return 'done';
+        await rest(progress);
+        if (!stale.has(locator)) {
+            if ((await (await openLocal()).order(locator)).length > 0)
+                submitLater(accepting, locator);
+            return 'done';
+        }
+        if (!repairable.has(locator))
+            return 'done';
+        const reset = repairable.get(locator);
+        return reset === undefined ? 'again' : { at: Date.parse(reset) };
+    }
+    function resendLater() {
+        if (!socket.isOpen())
+            return;
+        void recovery.attempt('resend', resendPass, { again: true });
+    }
+    async function resendPass(signal) {
+        if (!socket.isOpen() || closed || stopping || discoveryPaused)
+            return 'done';
+        const reading = { complete: true, reachable: true };
+        try {
+            await conversations.resend(reading);
+        }
+        catch {
+            reading.reachable = false;
         }
+        if (signal.aborted)
+            return 'done';
+        return reading.reachable && reading.complete ? 'done' : 'again';
     }
-    async function run() {
+    async function finishOpening(progress, live) {
         try {
-            await connect();
+            if (!live()) {
+                progress.complete = false;
+                return;
+            }
+            await submitAll(accepting);
+            for (const locator of stale)
+                if (repairable.has(locator))
+                    repairLater(locator, {});
+            await conversations.reconcile();
+            const reading = { complete: true, reachable: true };
+            await conversations.catchUp(reading);
+            if (progress.reachable && reading.reachable)
+                await conversations.resend(reading);
+            if (progress.reachable)
+                void recovery.attempt('calls', resendCalls);
+            if (!reading.reachable) {
+                progress.reachable = false;
+                resendLater();
+            }
+        }
+        catch {
+            progress.complete = false;
         }
         finally {
-            inflight = false;
-            if (queued && !closed) {
-                queued = false;
-                void enqueue();
+            if (live()) {
+                complete = progress.complete;
+                await rest(progress, live);
             }
         }
     }
-    function observeRoomVersions() {
-        const path = options.adapter.roomVersions;
-        if (path === undefined || withdrawNotifications !== undefined)
+    async function rest(progress, live = () => !closed) {
+        if (!live())
             return;
-        withdrawNotifications = path.observe((notification) => {
-            if (closed || stopping || discoveryPaused)
-                return;
-            if (notification.modelChanged === true && handed?.includes(notification.locator) === true) {
-                void enqueue();
+        const settled = () => complete && roomWork === 0 && !socket.naming() && stale.size === 0;
+        let synced = settled();
+        if (synced && !recorded) {
+            const queued = await queuedWork().catch(() => true);
+            if (!live())
                 return;
+            synced = !queued && settled();
+        }
+        if (synced && !recorded) {
+            const completedAt = new Date().toISOString();
+            try {
+                await (await openLocal()).fact('lastCompleted', completedAt);
+                if (!live())
+                    return;
+                recorded = true;
+            }
+            catch {
+                synced = false;
             }
-            notices.set(notification.locator, notification.roomVersion);
-            chain = chain.then(runNotified, runNotified);
+        }
+        moveTo({
+            state: synced && complete && roomWork === 0 && !socket.naming() ? 'synced' : 'syncing',
+            providerUnreachable: progress === null ? status.providerUnreachable : !progress.reachable,
+            resting: true,
         });
     }
+    function applyRoom(change) {
+        const { locator } = change;
+        if (stopping)
+            return Promise.resolve();
+        return inRoom(locator, async (live) => {
+            await socket.answered(locator);
+            const progress = underway ?? { complete: true, reachable: true };
+            try {
+                const local = await openLocal();
+                for (;;) {
+                    if (!live())
+                        return null;
+                    const room = discovered.get(locator);
+                    if (room === undefined || room.replica.admission !== 'admitted')
+                        return null;
+                    const held = await recordAt(locator);
+                    if (held === undefined) {
+                        if (change.from !== null)
+                            return null;
+                        await installCarried(room, local, change, live, progress);
+                        return progress;
+                    }
+                    if (held.replica.selection !== room.replica.selection)
+                        return null;
+                    const at = held.roomVersion;
+                    if (options.adapter.reached(locator, at, change.roomVersion))
+                        return progress;
+                    if (change.from === null || !options.adapter.reached(locator, at, change.from)) {
+                        await name(locator);
+                        return progress;
+                    }
+                    if (underway === null)
+                        moveTo(transferring());
+                    const writing = () => live() && !full;
+                    const refreshed = await store.ahead((hold) => pullRefresh(installer, authorization ?? {}, held, writing, hold, () => change.read()));
+                    if (refreshed.kind !== 'advanced')
+                        return progress;
+                    const landing = {
+                        kind: 'refreshed',
+                        from: refreshed.from,
+                        remodelled: refreshed.remodelled,
+                    };
+                    if (await publish(installer, local, room, refreshed.record, landing, writing)) {
+                        stale.delete(locator);
+                        if (!declaredAsHeld(held, room))
+                            await retainModel(local, room, null);
+                        return progress;
+                    }
+                }
+            }
+            catch {
+                if (!stale.has(locator))
+                    void name(locator);
+                stale.add(locator);
+                return progress;
+            }
+        }).then((progress) => rest(progress), () => undefined);
+    }
+    async function installCarried(room, local, change, live, progress) {
+        if (authorization === undefined)
+            return;
+        if (underway === null)
+            moveTo(transferring());
+        const prior = await recordAt(room.locator);
+        const from = standingAt(store, room.locator, prior);
+        const page = await change.read();
+        const carried = {
+            bootstrap: () => Promise.resolve({
+                kind: 'bootstrap',
+                roomVersion: page.roomVersion,
+                ...(page.models === undefined ? {} : { models: page.models }),
+                documents: page.documents,
+                facts: page.facts,
+                revisions: page.revisions,
+                ...(page.fileIds === undefined ? {} : { fileIds: page.fileIds }),
+                ...(page.created === undefined ? {} : { created: page.created }),
+                changes: page.changes,
+                binaryFiles: page.binaryFiles,
+                ...(page.folders === undefined ? {} : { folders: page.folders }),
+            }),
+            reached: (locator, roomVersion, target) => options.adapter.reached(locator, roomVersion, target),
+        };
+        const bootstrapped = await pullBootstrap(installer, authorization, room, local, live, prior, carried);
+        if (bootstrapped.kind !== 'staged') {
+            if (live())
+                await withhold(bootstrapped, room, local, progress);
+            return;
+        }
+        await publish(installer, local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
+    }
     function writesHeld() {
         return serviceMode === 'write-halted' || haltedRefusal;
     }
@@ -1706,224 +2588,244 @@ export function composeRuntime(options) {
             haltedRefusal = false;
         if (mode !== serviceMode) {
             serviceMode = mode;
+            queueReadiness();
             journal.record(`service mode ${mode}`);
             for (const listener of serviceModeListeners)
                 listener(mode);
         }
         if (releasing)
-            void enqueue();
+            submitAll(accepting);
     }
-    function observeConversations() {
-        const stream = options.adapter.conversations;
-        if (stream === undefined || withdrawConversations !== undefined)
-            return;
-        withdrawConversations = stream.observe((event) => {
-            conversations.receive(event);
-            if (event.kind !== 'gap' || conversations.current())
-                return;
-            show();
-            scheduleCurrency();
-        });
+    function haltedSince(opens) {
+        if (serviceMode === 'open' && openSignals !== opens)
+            return false;
+        haltedRefusal = true;
+        return true;
+    }
+    function pendingShown() {
+        if (!localSaves)
+            recorded = false;
+        return moveTo(localSaves ? status : { ...status, state: 'pending', resting: false });
     }
     function scheduleCurrency() {
-        if (currencyQueued || closed || stopping)
+        if (currencyQueued === socket.generation() || closed || stopping)
             return;
-        currencyQueued = true;
-        chain = chain.then(runCurrency, runCurrency);
+        currencyQueued = socket.generation();
+        void task(CONVERSATION_LANE, runCurrency);
     }
-    async function runCurrency() {
-        currencyQueued = false;
-        if (closed || stopping || discoveryPaused)
+    async function runCurrency(live) {
+        if (currencyQueued === socket.generation())
+            currencyQueued = null;
+        if (!live())
             return;
         await conversations.reconcile();
         if (conversations.current()) {
             show();
             return;
         }
-        const resting = status;
-        const progress = { complete: false, reachable: !resting.providerUnreachable };
-        moveTo(transferring(resting));
+        const progress = { complete: false, reachable: !status.providerUnreachable };
+        moveTo(transferring());
         try {
             await conversations.catchUp(progress);
         }
         catch {
             progress.reachable = false;
         }
-        finally {
-            if (!closed) {
-                moveTo(settled(resting, progress, resting.lastCompleted, pending(), attention()));
-            }
-        }
-    }
-    function handSelected(locators) {
-        const path = options.adapter.roomVersions;
-        if (path === undefined || withdrawNotifications === undefined)
-            return;
-        if (handed !== undefined && JSON.stringify(locators) === JSON.stringify(handed))
-            return;
-        handed = locators;
-        path.select(locators);
-    }
-    async function runNotified() {
-        const announced = [...notices];
-        notices.clear();
-        if (announced.length === 0 || closed || stopping || discoveryPaused)
-            return;
-        const resting = status;
-        const progress = { complete: false, reachable: !resting.providerUnreachable };
-        moveTo(transferring(resting));
-        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)
-                    continue;
-                if (sourceRefusals.has(locator)) {
-                    void enqueue();
-                    continue;
-                }
-                if (held === undefined)
-                    continue;
-                if (held.confirmed.record.roomVersion === roomVersion)
-                    continue;
-                const withheld = await advance(room, local, authorization);
-                if (withheld === null)
-                    continue;
-                if (withheld.kind === 'refused') {
-                    void enqueue();
-                    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') {
-                    await refuse('revoked-authorization');
-                    return;
-                }
-            }
-        }
-        catch {
-            progress.reachable = false;
-        }
-        finally {
-            if (!closed) {
-                moveTo(settled(resting, progress, resting.lastCompleted, pending(), attention()));
-            }
-        }
-    }
-    function enqueue() {
-        if (stopping)
-            return chain;
-        if (inflight) {
-            queued = true;
-            return chain;
-        }
-        inflight = true;
-        chain = chain.then(run, run);
-        return chain;
+        await rest(progress, live);
     }
     function close() {
         if (closed)
             return;
         closed = true;
-        withdrawNotifications?.();
-        withdrawNotifications = undefined;
-        withdrawConversations?.();
-        withdrawConversations = undefined;
+        notifyDiscovered();
+        unreadied();
+        if (probing !== null)
+            clearInterval(probing);
+        connectionLive();
+        lockListeners.clear();
+        readinessWatches.clear();
+        socket.withdraw();
         withdrawServiceMode?.();
         conversations.close();
-        stopTimer();
-        store?.close();
-        void opening?.then((opened) => {
-            opened.close();
-        }, () => { });
+        void recovery.retire();
         roomListeners.clear();
+        unlistedRooms.clear();
         refusalListeners.clear();
         storageLossListeners.clear();
         statusListeners.clear();
         serviceModeListeners.clear();
-        readSide.close();
+        memberListeners.clear();
+        authorityChangeListeners.clear();
+        liveQueries.close();
+        figures.close();
         queueSubscriptions.clear();
-        roomDraftListeners.clear();
-        presentationListeners.clear();
+        store.close();
     }
     async function stop() {
         stopping = true;
-        stopTimer();
-        await chain.catch(() => undefined);
-        await mutations;
+        unreadied();
+        socket.stopReads();
+        await recovery.retire();
+        await Promise.all(working);
+        await store.written();
         close();
     }
     const withdrawServiceMode = options.adapter.serviceMode?.observe(signalled);
-    observeConversations();
+    socket.observeConversations((event) => {
+        if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted')
+            queueReadiness();
+        conversations.receive(event);
+        if (event.kind !== 'gap' || conversations.current())
+            return;
+        show();
+        scheduleCurrency();
+    });
     options.signal?.addEventListener('abort', close, { once: true });
     if (options.signal?.aborted)
         close();
-    void openLocal().catch(() => {
-        notifyReady();
+    socket.observe(() => !closed && !stopping, (event) => {
+        if (event.kind === 'opened') {
+            connectionLive();
+            conversations.reopened();
+            lastAnswers.reopened();
+            recovery.resume();
+        }
+        else if (event.kind === 'discovered') {
+            if (event.missed)
+                countAuthorityChange();
+            void sync('opened', event.discovery);
+        }
+        else if (event.kind === 'closed')
+            closedSocket(event.revoked, event.lost, event.opened);
+        else if (event.kind === 'caught-up')
+            void caughtUpRooms(event.expired);
+        else if (event.kind === 'authority-changed') {
+            if (socket.isAnnounced() && socket.isOpen())
+                fenceLive(event.left);
+            void changeAuthority(event);
+        }
+        else
+            void applyRoom(event);
     });
-    void enqueue();
-    function 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);
+    void openLocal()
+        .then(async (local) => {
+        if ((await local.facts()).capabilities.length > 0)
+            readyFromStore();
+    })
+        .catch(() => {
+        readyFromStore();
+    });
+    if (options.adapter.roomStream === undefined)
+        void sync('unstreamed', null);
+    async function planned(input, reach) {
+        const plan = planWithin(input, await roomFacts(reach), planReach(reach));
+        const named = plan.paths !== null &&
+            plan.rooms !== null &&
+            plan.paths.length * plan.rooms.length <= MAXIMUM_WINDOW;
+        return plan.limit === null && named ? plan : { ...plan, limit: capped(plan.limit) };
+    }
+    function watchPlan(plan, deliver, fail) {
+        return watchSeeded(seeding, plan, deliver, (behind, answered) => liveQueries.watch(plan, identityOf(plan), (held) => {
+            const cover = covered(plan, held);
+            awaitPreparation(cover);
+            return behind(cover, held);
+        }, answered, fail));
+    }
+    function watchPlanned(planning, deliver, fail) {
+        let stop = null;
+        let stopped = false;
+        planning.then((plan) => {
+            if (!stopped)
+                stop = watchPlan(plan, deliver, fail);
+        }, (error) => {
+            if (!stopped)
+                fail(error);
+        });
+        return () => {
+            stopped = true;
+            stop?.();
+        };
+    }
+    async function searched(input, reach) {
+        const asked = searchPlanOf(input);
+        await ready;
+        const search = options.adapter.search;
+        if (search === undefined) {
+            return {
+                kind: 'undeclared',
+                code: 'action-undeclared',
+                fields: { name: 'search' },
+                retryable: false,
             };
         }
+        if (closed || refusal !== null || (await connectionNow()) !== 'connected')
+            return OFFLINE;
+        const reached = reach === null ? null : new Set(reach.rooms);
+        const named = asked.rooms === null
+            ? reached === null
+                ? null
+                : [...reached]
+            : asked.rooms.filter((room) => reached === null || reached.has(room));
+        const held = named === null ? null : await storedRooms(named);
+        const rooms = named === null ? null : named.filter((room) => held.has(room)).sort();
+        if (rooms !== null && rooms.length === 0)
+            return { kind: 'found', documents: [] };
+        try {
+            await ensureAuthorization();
+        }
+        catch {
+            return UNCERTAIN;
+        }
+        if (closed || authorization === undefined || refusal !== null)
+            return UNCERTAIN;
+        journal.record('transfer search');
+        try {
+            const result = await search(authorization, { text: asked.text, rooms });
+            if (result.kind === 'revoked-authorization')
+                await refuse('revoked-authorization');
+            journal.record(`outcome search ${result.kind}`);
+            if (result.kind === 'rejected')
+                return result;
+            if (result.kind !== 'found')
+                return failure(result);
+            const kept = rooms === null ? null : new Set(rooms);
+            return {
+                kind: 'found',
+                documents: result.documents.filter((hit) => kept === null || kept.has(hit.room)),
+            };
+        }
+        catch {
+            journal.record('outcome search transport-uncertainty');
+            return UNCERTAIN;
+        }
+    }
+    const watch = (topic, input, deliver, fail) => {
+        if (topic === 'room-drafts')
+            return watchRoomDrafts(drafting, deliver);
         if (topic === 'conversation') {
             return conversations.watch(input[0], input[1], 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 === 'conversations')
+            return conversations.watchList(deliver);
+        if (topic === 'agents')
+            return conversations.watchAgents(deliver);
+        if (topic === 'figures')
+            return figures.watch(deliver, fail);
+        if (topic === 'read')
+            return lastAnswers.watch(input[0], input[1], deliver);
+        if (topic === 'presentation')
+            return watchPresentation(drafting, input[0], deliver);
+        if (topic === 'readiness') {
+            return watchReadiness({ target: '', code: 'stored' }, null, deliver);
         }
         if (topic === 'rooms') {
-            roomListeners.add(deliver);
-            deliver(listed());
+            unlistedRooms.add(deliver);
+            emitKnownRooms();
             return () => {
+                unlistedRooms.delete(deliver);
                 roomListeners.delete(deliver);
+                if (roomListeners.size === 0)
+                    roomsShown = null;
             };
         }
         if (topic === 'connection-refusal') {
@@ -1954,152 +2856,162 @@ export function composeRuntime(options) {
                 serviceModeListeners.delete(deliver);
             };
         }
+        if (topic === 'member') {
+            memberListeners.add(deliver);
+            void openLocal()
+                .then((local) => local.facts())
+                .then(({ member }) => {
+                if (memberListeners.has(deliver))
+                    deliver(member);
+            }, () => { });
+            return () => {
+                memberListeners.delete(deliver);
+            };
+        }
+        if (topic === 'authority-changes') {
+            authorityChangeListeners.add(deliver);
+            deliver(authorityChanges);
+            return () => {
+                authorityChangeListeners.delete(deliver);
+            };
+        }
         if (topic === 'queue') {
             const queue = { locator: input[0], notify: deliver };
             queueSubscriptions.add(queue);
-            queue.notify(entriesOf(queue.locator));
+            void publication(async () => {
+                if (!queueSubscriptions.has(queue))
+                    return;
+                const entries = await entriesOf(queue.locator);
+                if (queueSubscriptions.has(queue))
+                    queue.notify(entries);
+            });
             return () => {
                 queueSubscriptions.delete(queue);
             };
         }
-        const plan = planOf(input[0], roomFacts());
-        return readSide.watch(plan, identityOf(plan), deliver);
-    }
+        return watchPlanned(planned(input[0], null), deliver, fail);
+    };
     const md = {
         loaded() {
             return openLocal().then(() => undefined);
         },
         rooms() {
-            return listed();
-        },
-        query: ((input) => readSide.query(planOf(input, roomFacts()))),
-        async search(input) {
-            const plan = searchPlanOf(input);
-            const selected = plan.documents === undefined
-                ? null
-                : (await readSide.query(filterOf(plan.documents, roomFacts())))
-                    .documents;
-            return searchIndex.search(plan, selected);
+            if (closed)
+                return Promise.resolve([]);
+            return new Promise((settle) => {
+                const answer = (value) => {
+                    unlistedRooms.delete(answer);
+                    roomListeners.delete(answer);
+                    settle(value);
+                };
+                unlistedRooms.add(answer);
+                emitKnownRooms();
+            });
         },
-        types(locator) {
+        query: ((input) => planned(input, null).then(rowsQuery)),
+        search: (input) => searched(input, null),
+        async types(locator) {
+            const held = (await storedRooms([locator])).get(locator);
+            const room = isFenced(locator) ? undefined : declarationOf(locator, held)?.room;
             return {
-                collection: modelTypes(modelOf(locator)),
-                typedSelection: rooms.get(locator)?.typedSelection === undefined ||
-                    rooms.get(locator)?.typedSelection === null
-                    ? null
-                    : modelTypes(modelOf(locator, 'typed-selection')),
+                collection: modelTypes(isFenced(locator) ? NO_MODEL : modelIn(locator, held)),
+                typedSelection: (room?.typedSelection ?? null) === null ? null : modelTypes(builtIn),
             };
         },
-        roomDraft: {
-            list() {
-                return exclusive(async () => {
-                    await openLocal();
-                    return snapshotRoomDrafts();
-                }).then((listed) => {
-                    publishRoomDrafts(true);
-                    return listed;
-                });
-            },
-            read(room, path) {
-                const record = roomDrafts.get(room)?.get(path);
-                return record === undefined ? null : roomDraftOf(record);
-            },
-            write(room, path, revision, input) {
-                return exclusive(async () => {
-                    const parts = readParts(input);
-                    if (path === '' || normalize(path) !== path)
-                        throw new Error('room-draft-malformed');
-                    const local = await openLocal();
-                    const current = roomDrafts.get(room)?.get(path);
-                    if ((current?.revision ?? null) !== revision) {
-                        return {
-                            outcome: 'stale',
-                            current: current === undefined ? null : roomDraftOf(current),
-                        };
-                    }
-                    const record = {
-                        locator: room,
-                        path,
-                        revision: roomDraftRevision(),
-                        parts: held(current?.parts, parts),
-                        returned: current?.returned ?? null,
-                    };
-                    await local.keepRoomDraft(record);
-                    rememberRoomDraft(record);
-                    publishChangeSet(changeSet(room, null, null, { drafts: [path] }));
-                    return { outcome: 'written', roomDraft: roomDraftOf(record) };
-                });
-            },
-            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 {
-                            outcome: 'stale',
-                            current: 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 };
-                });
-            },
-        },
+        roomDraft: roomDraftSurface(drafting),
         conversation: conversations.surface,
         chatDraft: conversations.chatDraft,
-        presentation: {
-            read(app) {
-                return exclusive(async () => {
-                    await openLocal();
-                    return presentationOf(app);
-                });
-            },
-            write(app, value) {
-                return exclusive(async () => {
-                    const local = await openLocal();
-                    const stored = structuredClone(value);
-                    await local.present({ app, value: stored });
-                    presentations.set(app, stored);
-                    publishChangeSet(changeSet('', null, null, { presentation: app }));
-                });
-            },
-        },
+        presentation: presentationSurface(drafting),
         save(room, named, writtenBy) {
-            return exclusive(() => saveRoomDrafts(room, named, writtenBy));
+            return exclusive(() => saveRoomDrafts(saver, room, named, writtenBy));
+        },
+        saveParts(room, parts, writtenBy) {
+            return exclusive(() => saveParts(saver, room, parts, writtenBy));
         },
         history(locator, path, query) {
             return readHistory(locator, path, query);
         },
-        call(name, input) {
-            return invokeAction(name, input);
+        resolve(room, path, destination) {
+            return resolveReference(room, path, destination);
+        },
+        binaryFile: binaryFileSurface(saver),
+        async call(name, input) {
+            await ready;
+            const lockedNow = await lockedRooms();
+            const room = (await calledRooms(name, input)).find((one) => lockedNow.includes(one));
+            return room === undefined ? recoveredAction(name, input) : lockedRoom(room);
         },
-        reached(locator, roomVersion, path) {
+        async reached(locator, roomVersion, path) {
             return path === undefined
-                ? reachedBy(locator, roomVersion)
-                : writtenAfter(locator, roomVersion, path);
+                ? reachedBy(installer, locator, roomVersion)
+                : writtenAfter(installer, locator, roomVersion, path);
         },
         log() {
             return journal.export();
         },
+        cleanUp,
+        unsent: () => database.ask({ kind: 'authored.unsent' }),
+        reset: () => options.shell.reset(),
+        async readAgain() {
+            lastAnswers.again();
+        },
         persistence() {
-            return options.shell.persistentStorage;
+            return persistence === 'granted';
+        },
+        async retry() {
+            journal.record('retry');
+            unpreparable.clear();
+            queueReadiness();
+            if (full)
+                await probed();
         },
-        observe: ((topic, ...input) => opened((deliver) => watch(topic, input, (message) => {
-            deliver(structuredClone(message));
-        }), topic === 'query')),
+        observe: observing(watch),
         async reauthorize() {
             if (refusal === null || !refusal.reauthorizationOffered)
                 return;
             journal.record('connection reauthorize');
-            await chain.catch(() => undefined);
-            await mutations;
+            await Promise.all([...lanes.values()]
+                .filter((held) => held.generation === socket.generation())
+                .map((held) => held.chain));
+            await store.written();
             authorization = undefined;
             discoveryPaused = false;
-            await enqueue();
+            if (options.adapter.roomStream === undefined)
+                await sync('unstreamed', null);
+            else
+                await task(OPENING_LANE, ensureAuthorization);
+        },
+    };
+    const reachable = {
+        md,
+        watch,
+        plan: planned,
+        query: (plan) => rowsQuery(plan),
+        watchPlan,
+        search: searched,
+        watchReadiness,
+        locked,
+        lockedRooms,
+        watchLocks,
+        located,
+        room: async (locator) => shownRooms(await listingNow()).find((one) => one.locator === locator),
+    };
+    return {
+        md,
+        seed: (entry) => keepEntrySeed(store, entry),
+        stop,
+        watch,
+        persisted(answer) {
+            if (answer === persistence)
+                return;
+            persistence = answer;
+            journal.record(`persistence ${answer}`);
+            queueReadiness();
+        },
+        within: (reach, port) => {
+            if (full)
+                void probed();
+            return narrowed(reachable, reach, port);
         },
     };
-    return { md, stop, watch };
 }