@agentshouse/mdruntime 0.1.0-c09bf842921ff → 0.1.0-c0c1e81da9166

package/dist/connection.js

@@ -1,8 +1,9 @@
 import { identityOf, parseFrontmatter, plain, queryKey, roomTarget, target, } from '@agentshouse/mdmodel';
 import { attachedModel, builtInModel, roomTypesOf, schemaTypes } from './attached-model.js';
-import { cached, modelTypes, NO_MODEL, sameModel, } from './model.js';
+import { modelTypes, NO_MODEL, } from './model.js';
 import { observing, whole } from './observation.js';
 import { planWithin, } from './query.js';
+import { createFigures, ROOM_TOTALS } from './figures.js';
 import { createLiveQueries } from './live.js';
 import { seededResult } from './seed.js';
 import { documentKey, roomOfKey } from './rows.js';
@@ -24,10 +25,9 @@ import { advancement } from './refresh.js';
 import { buildBatch, buildMove, joined, limiting, queuedDocuments, requeuing, } from './save.js';
 import { compositionOf, entryAt, landed, movedBy, overlayOf, replaying, returning, returnedPaths, slicing, slicingWith, standing, storedRecord, touchedBy, } from './replica.js';
 import { binaryBase, changedParts, changesOf, gatheredParts, held, heldFile, joinedDraft, moveTarget, readParts, readSavedParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
-import { same, saving, STARTING, transferring, } from './status.js';
+import { same, STARTING, } from './status.js';
 import { detectStorageLoss, nextGeneration, refusedForSpace, } from './durability.js';
 import { readinessOf, } from './readiness.js';
-import { FencedMap } from './fence.js';
 import { sameBinary } from './overlay.js';
 import { paced, ROW_WEIGHT, stepped, yielded } from './turn.js';
 import { roomDraftRevision } from './identity.js';
@@ -68,6 +68,8 @@ const STAGE_AIM_MS = 50;
 const STREAMS_HELD = 4;
 const NOTHING_HELD = { bytes: 0 };
 const QUEUED_TEXT = 1 << 23;
+// 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];
 // Bytes still arriving are reported at most this often, so readiness is not rebuilt for every chunk the network hands over while a slow link still moves the figure.
 const ARRIVAL_REPORT_MS = 250;
 // 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.
@@ -93,33 +95,24 @@ export function composeRuntime(options) {
     const roomTypes = roomTypesOf(options.adapter.roomTypes, options.adapter.nameableRoomTypes);
     let authorization = options.authorization;
     let opening;
-    const fences = new Map();
-    const isFenced = (locator) => fences.has(locator);
+    const fencedAt = new Map();
+    const isFenced = (locator) => fencedAt.has(locator);
     let fencings = 0;
     const lastFenced = new Map();
-    const fencedSince = (locator, since) => fences.has(locator) || (lastFenced.get(locator) ?? 0) > since;
+    const fencedSince = (locator, since) => fencedAt.has(locator) || (lastFenced.get(locator) ?? 0) > since;
     let discoveries = 0;
-    const replicas = new FencedMap(isFenced);
-    const reopened = new Set();
+    const confirmations = new Map();
     const usableWhenHeld = options.usableWhenHeld ?? [];
-    const queuesWithoutReplica = new FencedMap(isFenced);
-    const pendings = new Map();
     const landedAhead = new Map();
     const seeds = new Map();
     const seedWatchers = new Map();
-    const roomDrafts = new FencedMap(isFenced);
-    const attachedFiles = new FencedMap(isFenced);
-    const presentations = new Map();
-    let limits = [];
-    let capabilities = [];
-    const rooms = new FencedMap(isFenced);
-    const counted = new Map();
+    const attachedFiles = new Map();
+    const declared = new Map();
+    const unheldModels = new Map();
+    const typesHeld = new Map();
     const unreadable = new Set();
     const builtIn = builtInModel(roomTypes);
     const typedPaths = options.adapter.typedPaths ?? [];
-    const models = new FencedMap(isFenced);
-    const liveModels = new FencedMap(isFenced);
-    const invalidModels = new Set();
     const discovered = new Map();
     let inFlight = new AbortController();
     const refreshed = options.adapter.refresh?.bind(options.adapter);
@@ -134,23 +127,74 @@ export function composeRuntime(options) {
     };
     let roomsListed = false;
     const scopedRefusals = new Map();
-    function modelOf(locator) {
-        return models.get(locator) ?? NO_MODEL;
+    function typed(locator, persisted) {
+        if (persisted.status === 'unavailable')
+            return persisted;
+        const schema = persisted.snapshot.schema;
+        const held = typesHeld.get(locator);
+        if (held !== undefined && held.schema === schema)
+            return { ...persisted, types: held.types };
+        const types = schemaTypes(schema, roomTypes);
+        typesHeld.set(locator, { schema, types });
+        return { ...persisted, types };
     }
-    function savedModel(locator) {
-        return invalidModels.has(locator)
-            ? { status: 'unavailable', reason: 'revoked' }
-            : modelOf(locator);
+    function recordOf(stored) {
+        return { ...stored, model: typed(stored.locator, stored.model) };
     }
     function composed(record) {
         return compositionOf(record, builtIn, typedPaths);
     }
+    async function storedRooms(locators) {
+        const held = await (await openLocal()).rooms(locators);
+        return new Map(held
+            .filter(({ record }) => !isFenced(record.locator))
+            .map(({ record, indexed, documents }) => [
+            record.locator,
+            { record: recordOf(record), indexed, documents },
+        ]));
+    }
+    async function recordAt(locator) {
+        return (await storedRooms([locator])).get(locator)?.record;
+    }
+    async function workOf(locator) {
+        if (isFenced(locator))
+            return { replica: undefined, queue: [], states: new Map() };
+        const { room, queue } = await (await openLocal()).room(locator);
+        const batches = queue.map(({ batch }) => batch);
+        const states = new Map(queue.map(({ batch, state }) => [batch.id, state]));
+        return {
+            replica: room === null
+                ? undefined
+                : {
+                    record: recordOf(room.record),
+                    queue: batches,
+                    states,
+                    overlaid: room.overlaid,
+                    count: room.documents,
+                    confirmed: confirmations.get(locator) ?? 0,
+                    indexed: room.indexed,
+                },
+            queue: batches,
+            states,
+        };
+    }
+    async function replicaOf(locator) {
+        return (await workOf(locator)).replica;
+    }
+    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 composed({ ...record, model: savedModel(record.locator) });
+        return composed({
+            ...record,
+            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 closed = false;
@@ -164,6 +208,7 @@ export function composeRuntime(options) {
     const repairing = new Set();
     const calling = new Set();
     const repairable = new Map();
+    const unready = new Map();
     const answering = new Map();
     let complete = false;
     let recorded = false;
@@ -187,7 +232,17 @@ export function composeRuntime(options) {
     const queueSubscriptions = new Set();
     const roomDraftListeners = new Set();
     const presentationListeners = new Set();
-    const liveQueries = createLiveQueries((plan, cover) => answeredPlan(plan, cover));
+    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 withdrawConversations;
     let currencyQueued = null;
     let socketOpen = false;
@@ -200,15 +255,14 @@ export function composeRuntime(options) {
     let haltedRefusal = false;
     let openSignals = 0;
     const serviceModeListeners = new Set();
-    let member = null;
     const memberListeners = new Set();
     let authorityChanges = 0;
     const authorityChangeListeners = new Set();
     const unpreparedDemand = new Set();
     const unpreparable = new Set();
     let preparing = false;
-    let targets = {};
     let persistence = options.shell.persistence;
+    let heldWhenOpened = false;
     let full = false;
     let probing = null;
     let testing = null;
@@ -227,7 +281,7 @@ export function composeRuntime(options) {
     const readinessWatches = new Set();
     let readinessQueued = false;
     const catching = new Set();
-    const transfers = new FencedMap(isFenced);
+    const transfers = new Map();
     const installs = new Set();
     const arrivals = new Map();
     const streaming = new Set();
@@ -255,9 +309,16 @@ export function composeRuntime(options) {
         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: () => connectionOf() !== 'unreachable' && refusal === null,
+        online: () => (socketOpen || !status.providerUnreachable) && refusal === null,
         full: () => full,
         closed: () => closed,
         unanswered: resendLater,
@@ -277,26 +338,13 @@ export function composeRuntime(options) {
         notifyDiscovered();
         readyFromStore();
     }
-    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);
-    }
     async function visibleOf(locator, paths) {
-        const held = replicas.get(locator);
+        const held = await recordAt(locator);
         if (held === undefined)
             return undefined;
         const local = await openLocal();
-        const slice = await stepped(slicing(await local.entries(held.record.key, 'visible', paths), paths));
-        return { ...slice, collection: collectionOf(slice.documents, composed(held.record)) };
+        const slice = await stepped(slicing(await local.entries(held.key, 'visible', paths), paths));
+        return { ...slice, collection: collectionOf(slice.documents, composed(held)) };
     }
     function roomDraftOf(record, visible) {
         return structuredClone({
@@ -320,25 +368,45 @@ export function composeRuntime(options) {
             layers.set(locator, await visibleOf(locator, paths));
         return records.map((record) => roomDraftOf(record, layers.get(record.locator)));
     }
-    function snapshotRoomDrafts() {
-        const records = [...roomDrafts.values()].flatMap((room) => [...room.values()]);
-        records.sort((left, right) => {
+    async function draftsOf(locator, paths) {
+        const held = await (await openLocal()).roomDrafts(locator, paths);
+        return held.filter((record) => !isFenced(record.locator));
+    }
+    async function draftOf(locator, path) {
+        return (await draftsOf(locator, [path]))[0];
+    }
+    function inOrder(records) {
+        return [...records].sort((left, right) => {
             if (left.locator !== right.locator)
                 return left.locator < right.locator ? -1 : 1;
             if (left.path !== right.path)
                 return left.path < right.path ? -1 : 1;
             return 0;
         });
-        return roomDraftsOf(records);
     }
-    let draftsShown = Promise.resolve();
-    function publishRoomDrafts(waitingOnly) {
-        if (closed)
-            return;
-        const snapshot = snapshotRoomDrafts();
-        draftsShown = draftsShown.then(async () => {
-            const value = await snapshot.catch(() => null);
-            if (value === null || closed)
+    async function snapshotRoomDrafts() {
+        return roomDraftsOf(inOrder(await draftsOf()));
+    }
+    let published = Promise.resolve();
+    function publication(work) {
+        published = published.then(work).catch(unpublished);
+        return published;
+    }
+    function publishRoomDrafts(waitingOnly, touched = null) {
+        if (closed || roomDraftListeners.size === 0)
+            return Promise.resolve();
+        return publication(async () => {
+            if (closed || roomDraftListeners.size === 0)
+                return;
+            const records = await draftsOf();
+            if (closed)
+                return;
+            if (touched !== null &&
+                !records.some((record) => touched.some(({ locator, path }) => locator === record.locator && (path === null || path === record.path)))) {
+                return;
+            }
+            const value = await roomDraftsOf(inOrder(records));
+            if (closed)
                 return;
             for (const listener of roomDraftListeners) {
                 if (waitingOnly && listener.ready)
@@ -348,8 +416,8 @@ export function composeRuntime(options) {
             }
         });
     }
-    function presentationOf(app) {
-        const value = presentations.get(app);
+    async function presentationOf(app) {
+        const value = await (await openLocal()).presentation(app);
         return value === undefined ? null : structuredClone(value);
     }
     async function writtenRoomDraft(room, path, revision, input, next) {
@@ -357,7 +425,7 @@ export function composeRuntime(options) {
         if (path === '' || normalize(path) !== path)
             throw runtimeError('room-draft-malformed', `room-draft-malformed at ${path}: a path inside the Room, such as notes/a.md`);
         const local = await openLocal();
-        const current = roomDrafts.get(room)?.get(path);
+        const current = await draftOf(room, path);
         if ((current?.revision ?? null) !== revision) {
             return staleWrite(current === undefined ? null : ((await roomDraftsOf([current]))[0] ?? null));
         }
@@ -376,55 +444,34 @@ export function composeRuntime(options) {
         await local.keepRoomDraft(record, parts.file === undefined || file === undefined
             ? []
             : [{ key: file.localId, blob: parts.file.blob }]);
-        rememberRoomDraft(record);
-        publishChangeSet(changeSet(room, { drafts: [path] }));
+        await publishChangeSet(changeSet(room, { drafts: [path] }));
         return { outcome: 'written', roomDraft: (await roomDraftsOf([record]))[0] ?? null };
     }
     async function keptPresentation(app, next) {
         const local = await openLocal();
-        const stored = next(presentations.get(app));
+        const stored = next(await local.presentation(app));
         await local.present({ app, value: stored });
-        presentations.set(app, stored);
-        publishChangeSet(changeSet('', { presentation: app }));
+        await publishChangeSet(changeSet('', { presentation: app }));
     }
     function emitPresentation(app) {
-        if (closed)
-            return;
-        for (const listener of presentationListeners) {
-            if (listener.app === app && listener.ready)
-                listener.notify(presentationOf(app));
-        }
-    }
-    function pending() {
-        return (!localSaves &&
-            (queuesWithoutReplica.size > 0 ||
-                [...replicas.values()].some((replica) => replica.queue.length > 0)));
-    }
-    function unsent() {
-        const changed = new Map();
-        for (const room of [...replicas.keys(), ...queuesWithoutReplica.keys()]) {
-            for (const { batch, state } of entriesOf(room)) {
-                if (state === 'local')
-                    continue;
-                for (const { path } of batch.changes)
-                    changed.set(`${room}\u0000${path}`, { room, path });
-            }
-        }
-        return [...changed]
-            .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
-            .map(([, change]) => change);
+        const listening = () => [...presentationListeners].filter((listener) => listener.app === app && listener.ready);
+        if (closed || listening().length === 0)
+            return Promise.resolve();
+        return publication(async () => {
+            if (closed || listening().length === 0)
+                return;
+            const value = await presentationOf(app);
+            if (closed)
+                return;
+            for (const listener of listening())
+                listener.notify(value);
+        });
     }
-    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),
-            });
-        }
+    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;
@@ -432,41 +479,130 @@ export function composeRuntime(options) {
                 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;
+        const changed = new Map();
+        if (!localSaves) {
+            for (const change of held.unsent) {
+                if (!isFenced(change.room))
+                    changed.set(`${change.room}\u0000${change.path}`, change);
+            }
         }
-        return { attentionRequired, unsent: unsent(), reset };
+        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 documentsIn(locator) {
-        return replicas.get(locator)?.count ?? 0;
+    async function queuedWork() {
+        const held = await (await openLocal()).queued();
+        return !localSaves && held.some((locator) => !isFenced(locator));
     }
-    function listed() {
-        return structuredClone([...rooms.values()].map((room) => {
-            const documents = documentsIn(room.locator);
-            counted.set(room.locator, documents);
-            return locked(room.locator)
-                ? {
-                    ...room,
-                    model: modelTypes(NO_MODEL),
-                    typedSelection: null,
-                    documents: 0,
-                    locked: true,
-                }
-                : { ...room, documents, locked: false };
-        }));
+    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 locked(locator) {
-        return rooms.get(locator)?.replica.offline === 'locked' && !confirmed.has(locator);
+    function listedLocators(held) {
+        return [
+            ...declared.keys(),
+            ...[...held.keys()].filter((locator) => !declared.has(locator)),
+        ].filter((locator) => !isFenced(locator));
     }
-    function lockedRooms() {
-        return [...rooms.keys()].filter(locked).sort();
+    function selectionModel() {
+        return refusal?.code === 'revoked-authorization'
+            ? { status: 'unavailable', reason: 'revoked' }
+            : builtIn;
     }
-    function relocked(before) {
-        const after = lockedRooms();
+    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;
+    }
+    async function listingNow() {
+        return listingOf(await storedRooms());
+    }
+    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);
+        }
+        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}`);
@@ -489,9 +625,10 @@ export function composeRuntime(options) {
             lockGrace = null;
             if (socketOpen || closed)
                 return;
-            const before = lockedRooms();
-            confirmed.clear();
-            relocked(before);
+            void lockedRooms().then((before) => {
+                confirmed.clear();
+                return relocked(before);
+            }, () => { });
         }, LOCK_GRACE_MS);
     }
     function connectionLive() {
@@ -505,13 +642,14 @@ export function composeRuntime(options) {
             lockListeners.delete(notify);
         };
     }
-    function roomFacts(reach = null) {
-        const held = [...rooms.values()]
+    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 = [
-                ...(governed.collection ? [modelOf(room.locator)] : []),
+                ...(governed.collection ? [modelIn(room.locator, held.get(room.locator))] : []),
                 ...(governed.selection ? [builtIn] : []),
             ];
             return {
@@ -520,28 +658,86 @@ 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() {
-        liveQueries.recover();
+    function emitRooms(changed) {
+        recoverReads();
         queueReadiness();
-        const value = listed();
-        for (const listener of roomListeners)
-            listener(value);
-        emitKnownRooms();
+        return changed === undefined ? publishRooms('all') : publishRooms('changed', changed);
     }
     function emitKnownRooms() {
         conversations.learned();
         if (unlistedRooms.size === 0)
             return;
-        if (!roomsListed && rooms.size === 0 && refusal === null && !status.providerUnreachable)
-            return;
-        const value = listed();
-        for (const listener of [...unlistedRooms]) {
-            unlistedRooms.delete(listener);
-            roomListeners.add(listener);
-            listener(value);
+        void publishRooms('known');
+    }
+    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();
@@ -554,58 +750,98 @@ export function composeRuntime(options) {
         for (const listener of storageLossListeners)
             listener(storageLoss);
     }
-    function emitMember() {
+    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;
+            return Promise.resolve();
         queueReadiness();
         emitKnownRooms();
-        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);
+        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(locator, batch) {
+    function entryOf(states, batch) {
         if (localSaves)
             return Object.freeze({ batch, state: 'local' });
-        const state = pendings.get(pendingKey(locator, batch.id));
+        const state = states.get(batch.id);
         return Object.freeze({ batch, ...(state?.submission ?? { state: 'waiting' }) });
     }
-    function entriesOf(locator) {
-        return (replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? []).map((batch) => entryOf(locator, batch));
+    async function entriesOf(locator) {
+        if (isFenced(locator))
+            return [];
+        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) {
         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'}`);
     }
-    function indexed(locator) {
-        return replicas.get(locator)?.indexed === true;
-    }
     async function prepareReplica(locator) {
         for (;;) {
-            const held = replicas.get(locator);
+            const held = (await storedRooms([locator])).get(locator);
             if (held === undefined || closed || held.indexed)
                 return;
             const key = held.record.key;
@@ -613,20 +849,19 @@ export function composeRuntime(options) {
                 const local = await openLocal();
                 return timed(deriveBudget, () => local.rederive(key, composed(held.record), deriveBudget.bytes, DERIVE_LONGEST_MS, DERIVE_FLOOR));
             });
-            const now = replicas.get(locator);
-            if (now?.record.key !== key)
-                continue;
             if (!done.done)
                 continue;
-            replicas.set(locator, { ...now, indexed: true });
+            if ((await storedRooms([locator])).get(locator)?.record.key !== key)
+                continue;
             publishChangeSet(changeSet(locator, { documents: null }));
-            liveQueries.recover();
+            recoverReads();
             queueReadiness();
             return;
         }
     }
-    function unprepared() {
-        return [...unpreparedDemand, ...replicas.keys()].find((locator) => !indexed(locator) && !unpreparable.has(locator));
+    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);
@@ -641,7 +876,7 @@ export function composeRuntime(options) {
         preparing = true;
         void (async () => {
             try {
-                for (let waiting = unprepared(); waiting !== undefined; waiting = unprepared()) {
+                for (let waiting = await unprepared(); waiting !== undefined; waiting = await unprepared()) {
                     await yielded();
                     if (closed)
                         return;
@@ -649,6 +884,9 @@ export function composeRuntime(options) {
                     await prepareReplica(waiting).catch((error) => unpreparedBy(waiting, error));
                 }
             }
+            catch {
+                journal.record('preparation failed');
+            }
             finally {
                 preparing = false;
             }
@@ -657,31 +895,48 @@ export function composeRuntime(options) {
     function roomsOfReach(reach) {
         return new Set([...reach.rooms, ...reach.documents.map(roomOfKey)]);
     }
-    function reachedRooms(plan) {
+    async function covering() {
+        const held = await (await openLocal()).covering();
+        return {
+            rooms: new Map([...held.rooms].filter(([locator]) => !isFenced(locator))),
+            queues: new Map([...held.queues].filter(([locator]) => !isFenced(locator))),
+        };
+    }
+    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
-                ? [...new Set([...rooms.keys(), ...replicas.keys(), ...queuesWithoutReplica.keys()])]
-                : [...reached]);
+        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 ||
-            (rooms.has(locator) && discovered.get(locator)?.replica.admission === 'admitted'));
-    }
-    function covered(plan) {
-        const locators = reachedRooms(plan);
-        if (locators.length === 0 && plan.rooms === null && plan.reach === null && !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 = replicas.get(locator);
+            const replica = held.rooms.get(locator);
             if (replica === undefined) {
                 if (awaited(locator))
                     pending.push({ room: locator, awaits: 'acquisition' });
@@ -693,12 +948,12 @@ export function composeRuntime(options) {
             }
             coverage.push({
                 room: locator,
-                generation: replica.record.transfer,
+                generation: replica.transfer,
                 current: !(catching.has(locator) || transfers.has(locator)),
             });
-            read.push({ locator, key: replica.record.key });
-            for (const batch of replica.queue)
-                overlay.push(batch.id);
+            read.push({ locator, key: replica.key });
+            for (const id of held.queues.get(locator) ?? [])
+                overlay.push(id);
         }
         if (pending.length > 0)
             return { pending };
@@ -711,46 +966,54 @@ export function composeRuntime(options) {
         if (waiting.length > 0)
             prepare(waiting.map(({ room }) => room));
     }
-    function requiredRooms(given) {
+    function requiredRooms(given, held) {
         const reach = planReach(given);
+        const listed = new Set(listedLocators(held));
         if (reach === null)
-            return { listed: roomsListed, rooms: [...rooms.keys()].sort() };
+            return { listed: roomsListed, rooms: [...listed].sort() };
         const named = [...roomsOfReach(reach)].sort();
         if (roomsListed)
-            return { listed: true, rooms: named.filter((room) => rooms.has(room)) };
-        return { listed: named.every((room) => replicas.has(room)), rooms: named };
+            return { listed: true, rooms: named.filter((room) => listed.has(room)) };
+        return { listed: named.every((room) => held.has(room)), rooms: named };
     }
-    function roomState(locator) {
+    function roomState(locator, held) {
         const listedRoom = discovered.get(locator);
         if (roomsListed &&
             (listedRoom === undefined ||
                 listedRoom.replica.admission !== 'admitted' ||
                 unreadable.has(locator)))
             return 'unadmitted';
-        if (!replicas.has(locator))
+        const stored = held.get(locator);
+        if (stored === undefined)
             return 'acquiring';
-        if (!indexed(locator))
+        if (!stored.indexed)
             return 'preparing';
         return 'complete';
     }
     function conversationCoverage(reach) {
-        const declared = reach === null || reach.conversations;
-        if (!declared || options.adapter.conversations === undefined)
+        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() {
+    function connectionOf(lastCompleted) {
         if (socketOpen)
             return 'connected';
         if (status.providerUnreachable)
             return 'unreachable';
-        return options.adapter.roomStream === undefined && status.lastCompleted !== null
+        return options.adapter.roomStream === undefined && lastCompleted !== null
             ? 'connected'
             : 'connecting';
     }
-    function bytesOf(room, underway) {
+    async function connectionNow() {
+        if (socketOpen || status.providerUnreachable || options.adapter.roomStream !== undefined) {
+            return connectionOf(null);
+        }
+        return connectionOf((await (await openLocal()).facts()).lastCompleted);
+    }
+    function bytesOf(room, underway, held) {
         const transfer = transfers.get(room);
         if (transfer !== undefined) {
             const owed = (unindexed.get(room) ?? []).reduce((sum, part) => sum + part.bytes, 0);
@@ -759,10 +1022,10 @@ export function composeRuntime(options) {
                 total: Math.max(arrivals.get(room) ?? 0, transfer.done.bytes),
             };
         }
-        const held = underway ? NOTHING_HELD : (replicas.get(room)?.record.inventory ?? NOTHING_HELD);
-        return { done: held.bytes, total: arrivals.get(room) ?? held.bytes };
+        const kept = underway ? NOTHING_HELD.bytes : (held.get(room)?.bytes ?? NOTHING_HELD.bytes);
+        return { done: kept, total: arrivals.get(room) ?? kept };
     }
-    function installationOf(coverage) {
+    function installationOf(coverage, held) {
         const rooms = { done: 0, total: 0 };
         const bytes = { done: 0, total: 0 };
         let installing = 0;
@@ -778,7 +1041,7 @@ export function composeRuntime(options) {
                 installing += 1;
             if (underway && (streaming.has(room) || !arrivals.has(room)))
                 downloading = true;
-            const now = bytesOf(room, underway);
+            const now = bytesOf(room, underway, held);
             const earlier = underway ? startedOver.get(room) : undefined;
             bytes.done += Math.max(now.done, earlier?.done ?? 0);
             bytes.total += Math.max(now.total, earlier?.total ?? 0);
@@ -792,9 +1055,14 @@ export function composeRuntime(options) {
                     : 'replaying';
         return { step, rooms, bytes };
     }
-    function readinessFor(port, reach) {
-        const required = requiredRooms(reach);
-        const coverage = required.rooms.map((room) => ({ room, state: roomState(room) }));
+    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);
@@ -808,36 +1076,65 @@ export function composeRuntime(options) {
                 conversations: conversationCoverage(reach),
             },
             persistence,
-            connection: connectionOf(),
+            connection: connectionOf(facts.lastCompleted),
             house: refusal !== null ? 'refused' : writesHeld() ? 'write-halted' : 'open',
             space: full ? 'full' : null,
-            installation: installationOf(coverage),
+            installation: installationOf(coverage, held),
             lost: storageLoss !== null,
-            established: targets[port.target]?.established === true ||
-                (usableWhenHeld.includes(port.target) && required.rooms.some((room) => reopened.has(room))),
+            established: facts.targets[port.target]?.established === true ||
+                (heldWhenOpened && usableWhenHeld.includes(port.target)),
         });
     }
+    const establishing = new Set();
     function establish(name) {
-        targets = { ...targets, [name]: { established: true } };
-        queueReadiness();
-        probeEachMinute();
-        void durably((local) => local.fact('targets', targets)).catch(() => {
+        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) {
+    function deliverReadiness(watch, held) {
         if (!readinessWatches.has(watch))
             return;
-        const readiness = readinessFor(watch.port, watch.reach);
-        if (readiness.ready && targets[watch.port.target]?.established !== true) {
+        const readiness = readinessFor(watch.port, watch.reach, held);
+        if (readiness.ready && held.facts.targets[watch.port.target]?.established !== true) {
             establish(watch.port.target);
         }
-        const shown = JSON.stringify(readiness);
-        if (shown === watch.last)
+        const shownReadiness = JSON.stringify(readiness);
+        if (shownReadiness === watch.last)
             return;
-        watch.last = shown;
+        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;
@@ -846,14 +1143,13 @@ export function composeRuntime(options) {
             readinessQueued = false;
             if (closed)
                 return;
-            for (const watch of [...readinessWatches])
-                deliverReadiness(watch);
+            deliverAll([...readinessWatches]);
         });
     }
     function watchReadiness(port, reach, deliver) {
         const watch = { port, reach, deliver, last: null };
         readinessWatches.add(watch);
-        void openLocal().then(() => deliverReadiness(watch), () => deliverReadiness(watch));
+        void openLocal().then(() => deliverAll([watch]), () => deliverAll([watch]));
         return () => {
             readinessWatches.delete(watch);
         };
@@ -864,14 +1160,20 @@ export function composeRuntime(options) {
         full = true;
         journal.record('space full');
         queueReadiness();
-        probeEachMinute();
+        void probeEachMinute();
     }
-    function installedTarget() {
-        return ((usableWhenHeld.length > 0 && reopened.size > 0) ||
-            Object.values(targets).some((target) => target.established));
+    async function installedTarget() {
+        if (heldWhenOpened && usableWhenHeld.length > 0)
+            return true;
+        const { targets } = await (await openLocal()).facts();
+        return Object.values(targets).some((target) => target.established);
     }
-    function probeEachMinute() {
-        if (!full || probing !== null || closed || !installedTarget())
+    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(() => {
@@ -906,39 +1208,41 @@ export function composeRuntime(options) {
         else
             void resynchronize();
     }
-    function seedRoomHeld(room, version) {
-        return indexed(room) && reachedBy(room, version);
+    function seedRoomHeld(room, version, held) {
+        const stored = held.rooms.get(room);
+        return (stored !== undefined &&
+            stored.indexed &&
+            options.adapter.reached(room, stored.roomVersion, version));
     }
-    function seedHeld(at) {
-        return Object.entries(at).every(([room, version]) => (roomsListed && !rooms.has(room)) || seedRoomHeld(room, version));
+    function seedHeld(at, held) {
+        return Object.entries(at).every(([room, version]) => (roomsListed && !declared.has(room) && !held.rooms.has(room)) ||
+            seedRoomHeld(room, version, held));
     }
-    function seedApplies(plan) {
+    function seedApplies(plan, held) {
         const seed = seeds.get(plan.key);
         if (seed === undefined)
             return null;
-        if (!seedHeld(seed.at))
+        if (!seedHeld(seed.at, held))
             return seed;
         seeds.delete(plan.key);
         return null;
     }
-    function seedBehind(plan, cover) {
-        const seed = seedApplies(plan);
+    function seedBehind(plan, cover, held) {
+        const seed = seedApplies(plan, held);
         if (seed === null || 'pending' in cover)
             return cover;
         return {
             pending: Object.entries(seed.at)
-                .filter(([room, version]) => !seedRoomHeld(room, version))
+                .filter(([room, version]) => !seedRoomHeld(room, version, held))
                 .map(([room]) => ({ room, awaits: 'acquisition' })),
         };
     }
     function seed(entry) {
-        if (seedHeld(entry.at))
-            return;
         for (const { query, rows } of entry.queries) {
             const key = queryKey(query);
             seeds.set(key, { rows, at: entry.at });
-            for (const shown of seedWatchers.get(key) ?? [])
-                shown();
+            for (const shownSeed of seedWatchers.get(key) ?? [])
+                shownSeed();
         }
     }
     function sameCover(left, right) {
@@ -946,7 +1250,7 @@ export function composeRuntime(options) {
     }
     async function coveredRows(plan, cover) {
         for (;;) {
-            const before = cover();
+            const before = await cover();
             if ('pending' in before)
                 return { pending: before };
             const local = await openLocal();
@@ -954,7 +1258,7 @@ export function composeRuntime(options) {
             const changes = local.changes(keys);
             const current = () => local.changes(keys) === changes;
             const rows = await windowRows(local, plan, before.rooms, current);
-            const after = cover();
+            const after = await cover();
             if (rows !== null && sameCover(before, after))
                 return { rows, cover: before, current };
         }
@@ -1010,23 +1314,25 @@ export function composeRuntime(options) {
         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 before = covered(plan);
+        const held = await covering();
+        const before = covered(plan, held);
         awaitPreparation(before);
-        const seeded = seedApplies(plan);
+        const seeded = seedApplies(plan, held);
         if (seeded !== null)
             return seededResult(seeded).result;
         if ('pending' in before)
             return before;
-        const answered = await coveredRows(plan, () => {
-            const cover = covered(plan);
-            awaitPreparation(cover);
-            return cover;
-        });
+        const answered = await coveredRows(plan, () => coverNow(plan));
         if ('pending' in answered)
             return answered.pending;
-        const held = answered.cover;
-        return { ...answered.rows, coverage: held.coverage };
+        const shownCover = answered.cover;
+        return { ...answered.rows, coverage: shownCover.coverage };
     }
     function publishChangeSet(set) {
         applyChangeSet(set);
@@ -1034,21 +1340,24 @@ export function composeRuntime(options) {
             if (path !== null)
                 attachedFiles.get(locator)?.delete(path);
         }
-        if (set.rooms.length > 0 ||
-            [...new Set(set.documents.map(({ locator }) => locator))].some((locator) => rooms.has(locator) && counted.get(locator) !== documentsIn(locator)))
-            emitRooms();
-        for (const locator of set.queues)
-            emitQueue(locator);
-        if (set.drafts.length > 0 ||
-            set.documents.some((change) => {
-                const held = roomDrafts.get(change.locator);
-                return held !== undefined && (change.path === null || held.has(change.path));
-            })) {
-            publishRoomDrafts(false);
+        const shownNow = [];
+        if (set.queues.length > 0 || set.drafts.length > 0)
+            shownNow.push(show());
+        if (set.rooms.length > 0)
+            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)
+            shownNow.push(emitQueue(locator));
+        if (set.drafts.length > 0)
+            shownNow.push(publishRoomDrafts(false));
+        else if (set.documents.length > 0)
+            shownNow.push(publishRoomDrafts(false, set.documents));
         for (const app of set.presentations)
-            emitPresentation(app);
+            shownNow.push(emitPresentation(app));
         conversations.changed(set);
+        return Promise.all(shownNow).then(() => undefined);
     }
     async function refuse(reason, provider = null) {
         discoveryPaused = true;
@@ -1058,53 +1367,31 @@ export function composeRuntime(options) {
             if (reason === 'revoked-authorization') {
                 await exclusive(async () => {
                     const revoked = { status: 'unavailable', reason: 'revoked' };
-                    const records = [...replicas].map(([locator, held]) => ({
-                        locator,
-                        held,
-                        record: { ...held.record, model: revoked },
-                    }));
-                    let answer = null;
+                    let held = new Map();
                     try {
                         const local = await openLocal();
-                        answer = await local.commit({
-                            rooms: records.map(({ locator, record }) => ({
-                                locator,
-                                key: record.key,
-                                record: storedRecord(record),
-                                composed: composedOf(composed(record)),
-                            })),
+                        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(), ...rooms.keys()]);
-                    for (const key of keys) {
-                        invalidModels.add(key);
-                        models.set(key, revoked);
-                        liveModels.delete(key);
-                    }
-                    const changed = [];
-                    for (const { locator, held, record } of records) {
-                        if (replicas.get(locator) !== held)
-                            continue;
-                        const indexed = answer === null ? held.indexed : committedRoom(locator, answer).indexed;
-                        replicas.set(locator, { ...held, record, indexed });
-                    }
-                    for (const locator of [...rooms.keys()]) {
-                        const room = rooms.get(locator);
-                        if (room === undefined)
-                            continue;
-                        rooms.set(locator, {
-                            ...room,
-                            model: modelTypes(revoked),
-                            typedSelection: room.typedSelection === null
-                                ? null
-                                : { ...room.typedSelection, model: modelTypes(revoked) },
-                        });
-                        changed.push(changeSet(locator, { documents: null, room: true }));
+                    const listedNow = listedLocators(held);
+                    for (const locator of listedNow) {
+                        if (!held.has(locator))
+                            unheldModels.set(locator, revoked);
                     }
-                    publishChangeSet(mergeChangeSets(changed));
+                    publishChangeSet(mergeChangeSets(listedNow.map((locator) => changeSet(locator, { documents: null, room: true }))));
                     prepare();
                 });
             }
@@ -1121,49 +1408,66 @@ export function composeRuntime(options) {
         }
     }
     function list(room, synchronizationAvailable) {
-        const selection = room.typedSelection ?? null;
-        rooms.set(room.locator, {
-            name: room.name,
-            locator: room.locator,
-            handle: room.handle,
-            operations: room.operations,
-            replica: room.replica,
-            model: modelTypes(modelOf(room.locator)),
-            typedSelection: selection === null
-                ? null
-                : {
-                    roots: selection.roots,
-                    model: modelTypes(builtIn),
-                },
-            providerOwnedPaths: room.providerOwnedPaths,
-            roomVersion: replicas.get(room.locator)?.record.roomVersion ?? null,
-            synchronizationAvailable,
-            refusal: scopedRefusals.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,
         });
     }
+    function listHeld(locator) {
+        if (isFenced(locator))
+            return;
+        declared.set(locator, { room: null, available: false });
+    }
     async function applyDiscovery(found, started, left) {
-        const lockedBefore = lockedRooms();
-        for (const room of found) {
-            const fence = fences.get(room.locator);
-            if (fence !== undefined && fence.erased && fence.at < started)
-                fences.delete(room.locator);
+        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 = fencedAt.get(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 = fencedAt.get(locator);
+            if (fence === undefined || fence.at >= started)
+                continue;
+            if (relisted.has(locator) || (!stillFenced.has(locator) && !fence.written)) {
+                fencedAt.delete(locator);
+            }
         }
+        const kept = await local.held();
         await loseRooms(found
-            .filter((room) => room.replica.admission !== 'admitted' && heldLocally(room.locator))
+            .filter((room) => room.replica.admission !== 'admitted' &&
+            (kept.held.has(room.locator) || transfers.has(room.locator)))
             .map((room) => room.locator));
-        const listed = found.filter((room) => !fences.has(room.locator));
-        const listedLocators = new Set(listed.map((room) => room.locator));
-        for (const locator of listedLocators)
+        const listed = found.filter(({ locator }) => !fencedAt.has(locator) && (!stillFenced.has(locator) || relisted.has(locator)));
+        const listedLocatorsNow = new Set(listed.map((room) => room.locator));
+        for (const locator of listedLocatorsNow)
             scopedRefusals.delete(locator);
         if (left === undefined)
             discovered.clear();
         for (const room of listed)
             discovered.set(room.locator, room);
-        await loseRooms(left ?? unlistedHeld(new Set(found.map((room) => room.locator))));
+        const named = new Set(found.map((room) => room.locator));
+        await loseRooms(left ??
+            [...new Set([...declared.keys(), ...kept.held, ...transfers.keys()])].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)?.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));
@@ -1171,74 +1475,36 @@ export function composeRuntime(options) {
         confirmLocks(listed);
         roomsListed = true;
         emitRooms();
-        relocked(lockedBefore);
+        await relocked(lockedBefore);
         return listed;
     }
-    function heldLocally(locator) {
-        return (replicas.has(locator) ||
-            roomDrafts.has(locator) ||
-            transfers.has(locator) ||
-            queuesWithoutReplica.has(locator));
-    }
-    function unlistedHeld(listed) {
-        return [
-            ...new Set([
-                ...rooms.keys(),
-                ...roomDrafts.keys(),
-                ...transfers.keys(),
-                ...queuesWithoutReplica.keys(),
-            ]),
-        ].filter((locator) => !listed.has(locator));
-    }
-    function fence(locators) {
-        const fresh = [...new Set(locators)].filter((locator) => !fences.has(locator));
-        const removed = fresh.map((locator) => ({
-            locator,
-            drafts: [...(roomDrafts.get(locator)?.keys() ?? [])],
-        }));
-        for (const locator of fresh) {
-            fences.set(locator, { at: discoveries, erased: false });
-            lastFenced.set(locator, ++fencings);
-            confirmed.delete(locator);
-            for (const batch of replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? []) {
-                pendings.delete(pendingKey(locator, batch.id));
-                landedAhead.delete(pendingKey(locator, batch.id));
-            }
-            replicas.delete(locator);
-            highest.delete(locator);
-            beyondHorizon.delete(locator);
-            queuesWithoutReplica.delete(locator);
-            rooms.delete(locator);
-            roomDrafts.delete(locator);
-            attachedFiles.delete(locator);
-            untransferred(locator);
-            startedOver.delete(locator);
-            catching.delete(locator);
-            discovered.delete(locator);
-            unreadable.delete(locator);
-            stale.delete(locator);
-            repairable.delete(locator);
-            unpreparable.delete(locator);
-            scopedRefusals.delete(locator);
-            models.delete(locator);
-            liveModels.delete(locator);
-            invalidModels.delete(locator);
-            journal.record(`room lost ${locator}`);
-        }
-        if (fresh.length === 0)
-            return fresh;
-        publishChangeSet(mergeChangeSets(removed.map(({ locator, drafts }) => changeSet(locator, { documents: null, room: true, queue: true, drafts }))));
-        liveQueries.recover();
-        moveTo({ ...status, ...attention() });
-        return fresh;
+    function forget(locator) {
+        confirmed.delete(locator);
+        for (const key of [...landedAhead.keys()]) {
+            if (key.startsWith(`${locator}\u0000`))
+                landedAhead.delete(key);
+        }
+        confirmations.delete(locator);
+        highest.delete(locator);
+        beyondHorizon.delete(locator);
+        declared.delete(locator);
+        attachedFiles.delete(locator);
+        untransferred(locator);
+        startedOver.delete(locator);
+        catching.delete(locator);
+        discovered.delete(locator);
+        unreadable.delete(locator);
+        stale.delete(locator);
+        repairable.delete(locator);
+        unpreparable.delete(locator);
+        scopedRefusals.delete(locator);
+        unheldModels.delete(locator);
+        typesHeld.delete(locator);
     }
     async function eraseFenced(locators) {
         for (const locator of locators) {
             while (await durably((local) => local.erase(locator, ERASE_BATCH)))
                 await yielded();
-            const held = fences.get(locator);
-            if (held !== undefined)
-                held.erased = true;
         }
     }
     let sweeping = false;
@@ -1260,147 +1526,60 @@ export function composeRuntime(options) {
             }
         })();
     }
+    function fenceLive(locators) {
+        for (const locator of new Set(locators)) {
+            if (fencedAt.has(locator))
+                continue;
+            fencedAt.set(locator, { at: discoveries, written: false });
+            lastFenced.set(locator, ++fencings);
+            forget(locator);
+            journal.record(`room lost ${locator}`);
+        }
+    }
     async function loseRooms(locators) {
-        const fresh = fence(locators);
+        fenceLive(locators);
+        const fresh = [...new Set(locators)].filter((locator) => {
+            const fence = fencedAt.get(locator);
+            if (fence === undefined || fence.written)
+                return false;
+            fence.written = true;
+            return true;
+        });
         if (fresh.length === 0)
             return;
-        await durably(async (local) => {
-            await local.fence(fresh);
-            await unpair(local);
-        });
-        await eraseFenced(fresh);
-    }
-    function retyped(persisted) {
-        if (persisted.status === 'unavailable')
-            return persisted;
-        return { ...persisted, types: schemaTypes(persisted.snapshot.schema, roomTypes) };
-    }
-    function restored(key, held) {
-        const persisted = retyped(held);
-        const prior = models.get(key);
-        if (prior !== undefined &&
-            prior.status !== 'unavailable' &&
-            (persisted.status === 'unavailable' || !sameModel(prior.snapshot, persisted.snapshot))) {
-            invalidModels.add(key);
-        }
-        const model = persisted.status === 'unavailable' ||
-            liveModels.get(key) === JSON.stringify(persisted.snapshot)
-            ? persisted
-            : cached(persisted);
-        models.set(key, model);
-        if (model.status === 'unavailable') {
-            liveModels.delete(key);
-            invalidModels.delete(key);
-        }
-        return model;
-    }
-    async function hydrate(opened) {
-        const [held, queues, kept, heldConversations, chatDrafts] = await Promise.all([
-            opened.opened(),
-            opened.queues(),
-            opened.roomDrafts(),
-            opened.conversations(),
-            opened.chatDrafts(),
-        ]);
-        const records = [...held.rooms.values()];
-        const counts = await opened.counts(records.map(({ key, typedSelection }) => ({ key, roots: typedSelection?.roots ?? [] })));
-        const queuedBatches = new Map(queues.map((queue) => [queue.locator, queue.pending.map(({ batch }) => batch)]));
-        targets = held.targets;
-        transfers.clear();
-        arrivals.clear();
-        streaming.clear();
-        startedOver.clear();
-        limits = held.providerLimits;
-        capabilities = held.capabilities;
-        member = held.member;
-        roomDrafts.clear();
-        for (const record of kept)
-            rememberRoomDraft(record);
-        presentations.clear();
-        for (const record of held.presentation)
-            presentations.set(record.app, record.value);
-        conversations.hydrate(heldConversations, chatDrafts, held.conversationList, held.conversationCursor);
-        pendings.clear();
-        landedAhead.clear();
-        for (const queue of queues) {
-            for (const { batch, state } of queue.pending) {
-                pendings.set(pendingKey(queue.locator, batch.id), state);
-            }
-        }
-        replicas.clear();
-        reopened.clear();
-        queuesWithoutReplica.clear();
-        for (const [locator, queue] of queuedBatches) {
-            if (!held.rooms.has(locator))
-                queuesWithoutReplica.set(locator, queue);
-        }
-        records.forEach((stored, index) => {
-            if (fences.has(stored.locator))
-                return;
-            const record = { ...stored, model: restored(stored.locator, stored.model) };
-            reopened.add(record.locator);
-            replicas.set(record.locator, {
-                record,
-                queue: queuedBatches.get(record.locator) ?? [],
-                overlaid: held.overlaid.get(record.key) ?? new Set(),
-                count: counts[index] ?? 0,
-                confirmed: 0,
-                indexed: !held.unindexed.has(record.key),
-            });
-            const existing = rooms.get(record.locator);
-            if (existing === undefined)
-                list(record, record.roomVersion !== null);
-            else {
-                rooms.set(record.locator, {
-                    ...existing,
-                    roomVersion: record.roomVersion,
-                    operations: record.operations,
-                    replica: record.replica,
-                    model: modelTypes(record.model),
-                    typedSelection: record.typedSelection === null
-                        ? null
-                        : { roots: record.typedSelection.roots, model: modelTypes(builtIn) },
-                });
-            }
-        });
+        let held = [];
         try {
-            for (const key of held.orphans)
-                await opened.release(key);
+            await durably(async (local) => {
+                held = await local.roomDrafts();
+                await local.fence(fresh);
+            });
         }
         catch (error) {
-            if (!refusedForSpace(error))
-                throw error;
+            for (const locator of fresh) {
+                const fence = fencedAt.get(locator);
+                if (fence !== undefined)
+                    fence.written = false;
+            }
+            throw error;
         }
-        if (held.erasing || held.orphans.length > 0)
-            queueMicrotask(sweep);
-        return {
-            lastCompleted: held.lastCompleted,
-            locators: new Set([...queuedBatches.keys(), ...replicas.keys()]),
-            read: mergeChangeSets([...replicas.keys()].map((locator) => changeSet(locator, { documents: null }))),
-        };
-    }
-    async function readState(opened) {
-        const { lastCompleted, locators, read } = await hydrate(opened);
-        applyChangeSet(read);
-        prepare();
-        if (replicas.size > 0)
-            emitRooms();
-        if (member !== null)
-            emitMember();
-        for (const locator of locators)
-            emitQueue(locator);
-        publishRoomDrafts(false);
-        return lastCompleted;
+        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(unpair);
+        await eraseFenced(fresh);
     }
     async function open() {
         if (closed)
             throw new Error('runtime closed');
-        const opened = openRuntimeStore(isFenced, database);
+        const opened = openRuntimeStore(database);
         const interrupted = await opened.fences();
-        for (const locator of interrupted) {
-            fences.set(locator, { at: discoveries, erased: false });
-            lastFenced.set(locator, ++fencings);
-        }
         const kept = options.shell.generation;
         const storedGeneration = await opened.generation();
         const loss = detectStorageLoss(storedGeneration, kept);
@@ -1413,7 +1592,20 @@ export function composeRuntime(options) {
             storageLoss = loss;
             emitStorageLoss();
         }
-        const lastCompleted = await readState(opened);
+        const held = await opened.opened();
+        heldWhenOpened = usableWhenHeld.length > 0 && (await opened.covering()).rooms.size > 0;
+        try {
+            await opened.demote();
+            for (const key of held.orphans)
+                await opened.release(key);
+        }
+        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(() => {
@@ -1421,7 +1613,9 @@ export function composeRuntime(options) {
                 });
             });
         }
-        moveTo({ ...status, lastCompleted, ...attention() });
+        moveTo(status);
+        prepare();
+        emitRooms();
         void exclusive(() => unpair(opened)).catch(() => {
             journal.record('unpair failed');
         });
@@ -1464,9 +1658,9 @@ export function composeRuntime(options) {
         gathering = entry;
         return entry.done;
     }
-    function withdrawable(locator) {
+    function withdrawable(states) {
         return (batch) => {
-            const state = pendings.get(pendingKey(locator, batch.id));
+            const state = states.get(batch.id);
             return state !== undefined && state.submission.state !== 'submitted' && !state.lost;
         };
     }
@@ -1488,13 +1682,13 @@ export function composeRuntime(options) {
         const partner = partnerOf(batch, locator);
         if (partner === null)
             return true;
-        const other = replicas.get(partner);
+        const other = await replicaOf(partner);
         const half = other?.queue.find((one) => one.id === batch.id);
         if (other === undefined || half === undefined)
             return false;
         return landed(half, await sliceAt(other.record, 'confirmed', [half]));
     }
-    function carriedBack(locator, unlanded, written) {
+    async function carriedBack(locator, unlanded, written) {
         const back = new Map();
         const taken = [];
         for (const batch of unlanded) {
@@ -1503,13 +1697,15 @@ export function composeRuntime(options) {
                 continue;
             const source = between.source.room;
             const destination = between.destination.room;
-            for (const { path: to } of pendings.get(pendingKey(destination, batch.id))?.drafts ?? []) {
-                const record = roomDrafts.get(destination)?.get(to);
+            const local = await openLocal();
+            const arrived = (await local.pending(destination, batch.id)).state?.drafts ?? [];
+            for (const { path: to } of arrived) {
+                const record = await draftOf(destination, to);
                 const path = between.moves.find((move) => move.to === to)?.path;
                 if (record === undefined || path === undefined)
                     continue;
                 const [into, key] = source === locator ? [written, path] : [back, documentKey(source, path)];
-                const existing = into.get(key) ?? roomDrafts.get(source)?.get(path);
+                const existing = into.get(key) ?? (await draftOf(source, path));
                 taken.push({ locator: destination, path: to });
                 into.set(key, {
                     locator: source,
@@ -1535,19 +1731,14 @@ export function composeRuntime(options) {
                     .filter((one) => one.locator === room)
                     .map(({ path }) => path),
             })),
-            remember() {
-                for (const one of taken)
-                    forgetRoomDraft(one.locator, one.path);
-                for (const record of records)
-                    rememberRoomDraft(record);
-            },
         };
     }
-    function committedRoom(locator, answer) {
-        const indexed = answer.indexed[locator] ?? replicas.get(locator)?.indexed ?? false;
-        if (!indexed)
+    function preparedAfter(locator, answer) {
+        if (answer.indexed[locator] === false)
             prepare([locator]);
-        return { count: answer.counts[locator] ?? replicas.get(locator)?.count ?? 0, indexed };
+    }
+    function confirmedAgain(locator) {
+        confirmations.set(locator, (confirmations.get(locator) ?? 0) + 1);
     }
     function replayed(record, confirmedLayer, queue) {
         return stepped(replaying(confirmedLayer, queue, record.locator, composed(record)));
@@ -1564,13 +1755,14 @@ export function composeRuntime(options) {
             touched,
         };
     }
-    async function settle(local, locator, before, record, queue, settling = {}) {
-        return together(local, [await settlement(local, locator, before, record, queue, settling)]);
+    async function settle(local, locator, work, record, queue, settling = {}) {
+        return together(local, [await settlement(local, locator, work, record, queue, settling)]);
     }
-    function unpairedIn(locator, batch) {
-        if (!queueIn(locator).some((held) => held.id === batch.id))
+    async function unpairedIn(locator, batch) {
+        const { state } = await (await openLocal()).pending(locator, batch.id);
+        if (state === undefined)
             return false;
-        return !leavingIn(batch, locator) || withdrawable(locator)(batch);
+        return !leavingIn(batch, locator) || withdrawable(new Map([[batch.id, state]]))(batch);
     }
     async function together(local, settlements) {
         const settled = new Set(settlements.map(({ locator }) => locator));
@@ -1580,8 +1772,9 @@ export function composeRuntime(options) {
             for (const { locator, left } of wave) {
                 for (const batch of left) {
                     const partner = partnerOf(batch, locator);
-                    if (partner === null || settled.has(partner) || !unpairedIn(partner, batch))
+                    if (partner === null || settled.has(partner) || !(await unpairedIn(partner, batch))) {
                         continue;
+                    }
                     partnered.set(partner, [...(partnered.get(partner) ?? []), batch]);
                 }
             }
@@ -1599,9 +1792,10 @@ export function composeRuntime(options) {
         });
         return mergeChangeSets(all.map((one) => one.apply(answer)));
     }
-    async function settlement(local, locator, before, record, queue, settling = {}) {
+    async function settlement(local, locator, work, record, queue, settling = {}) {
+        const before = work.replica;
         const view = settling.view ?? 'confirmed';
-        const previousQueue = before?.queue ?? queuesWithoutReplica.get(locator) ?? [];
+        const previousQueue = work.queue;
         const overrides = settling.changes;
         const read = await sliceAt(record, view, queue, [
             ...(before !== undefined && before.record.key === record.key ? before.overlaid : []),
@@ -1618,7 +1812,7 @@ export function composeRuntime(options) {
                 Object.entries(held).some(([path, revision]) => confirmedLayer.revisions[path] !== revision));
         });
         const unshown = queue.filter((batch) => !shown.includes(batch));
-        const { withdrawn, kept } = await stepped(standing(confirmedLayer, unshown, withdrawable(locator), localSaves, locator, composition));
+        const { withdrawn, kept } = await stepped(standing(confirmedLayer, unshown, withdrawable(work.states), localSaves, locator, composition));
         const founded = kept.filter((batch) => !unshown.includes(batch));
         const queueChanged = kept.length !== previousQueue.length || founded.length > 0;
         const unqueued = shown.map((batch) => ({ batch, landed: true }));
@@ -1636,8 +1830,8 @@ export function composeRuntime(options) {
         for (const { batch, returned: reason } of returning) {
             if (reason === null || batch.between?.destination.room === locator)
                 continue;
-            for (const saved of pendings.get(pendingKey(locator, batch.id))?.drafts ?? []) {
-                const existing = written.get(saved.path) ?? roomDrafts.get(locator)?.get(saved.path);
+            for (const saved of work.states.get(batch.id)?.drafts ?? []) {
+                const existing = written.get(saved.path) ?? (await draftOf(locator, saved.path));
                 written.set(saved.path, {
                     locator,
                     path: saved.path,
@@ -1647,12 +1841,12 @@ export function composeRuntime(options) {
                 });
             }
         }
-        const carried = carriedBack(locator, [
+        const carried = await carriedBack(locator, [
             ...[...unqueued].reverse().flatMap(({ batch, landed: held }) => (held ? [] : [batch])),
             ...(settling.leaving ?? []).flatMap(({ batch, returned }) => returned === null ? [] : [batch]),
         ], written);
         const replayedLayer = await replayed(record, confirmedLayer, kept);
-        const { overlay, touched } = await overlayDiff(record, before, replayedLayer.visible, replayedLayer.touched);
+        const { overlay } = await overlayDiff(record, before, replayedLayer.visible, replayedLayer.touched);
         const commit = {
             rooms: [
                 {
@@ -1672,6 +1866,7 @@ export function composeRuntime(options) {
                 {
                     locator,
                     queue: kept,
+                    stored: previousQueue,
                     founded,
                     roomDrafts: [...written.values()],
                     consumedRoomDrafts: carried.taken,
@@ -1686,33 +1881,21 @@ export function composeRuntime(options) {
             commit,
             apply: (answer) => {
                 for (const batch of previousQueue) {
-                    if (staying.has(batch.id))
-                        continue;
-                    pendings.delete(pendingKey(locator, batch.id));
-                    landedAhead.delete(pendingKey(locator, batch.id));
+                    if (!staying.has(batch.id))
+                        landedAhead.delete(pendingKey(locator, batch.id));
                 }
-                for (const draft of written.values())
-                    rememberRoomDraft(draft);
-                carried.remember();
                 const drafts = [...written.keys(), ...carried.taken];
-                queuesWithoutReplica.delete(locator);
                 for (const { batch, landed: held } of unqueued) {
                     const outcome = localSaves ? 'dropped' : held ? 'landed' : 'withdrawn';
                     journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
                 }
                 const changed = answer.changed[locator];
-                const confirmedChanged = settling.commit?.published !== undefined ||
+                if (settling.commit?.published !== undefined ||
                     settling.commit?.refreshed === true ||
-                    overrides !== undefined;
-                const { count, indexed } = committedRoom(locator, answer);
-                replicas.set(locator, {
-                    record,
-                    queue: kept,
-                    overlaid: touched,
-                    count,
-                    confirmed: (before?.confirmed ?? 0) + (confirmedChanged ? 1 : 0),
-                    indexed,
-                });
+                    overrides !== undefined) {
+                    confirmedAgain(locator);
+                }
+                preparedAfter(locator, answer);
                 return mergeChangeSets([
                     changeSet(locator, {
                         documents: changed === undefined ? [] : changed,
@@ -1725,22 +1908,11 @@ export function composeRuntime(options) {
             },
         };
     }
-    function adoptModels(locator, record) {
-        const model = record.model;
-        models.set(locator, model);
-        invalidModels.delete(locator);
-        if (model.status === 'current')
-            liveModels.set(locator, JSON.stringify(model.snapshot));
-        else if (model.status === 'unavailable')
-            liveModels.delete(locator);
-    }
-    function remodel(locator, answers, held) {
+    function remodel(answers, held) {
         const answer = answers?.collection;
         if (answer === undefined)
             return held;
-        const state = attachedModel(answer, roomTypes);
-        models.set(locator, state);
-        return { collection: state };
+        return { collection: attachedModel(answer, roomTypes) };
     }
     function publish(local, room, reached, landing, live) {
         const landed = exclusive(async () => {
@@ -1748,8 +1920,9 @@ export function composeRuntime(options) {
                 caughtUpTo(room.locator);
                 return true;
             }
-            const prior = replicas.get(room.locator);
-            if (!stands(room.locator, landing.from)) {
+            const work = await workOf(room.locator);
+            const prior = work.replica;
+            if (!standsAt(room.locator, prior, landing.from)) {
                 if (landing.kind === 'refreshed') {
                     await local.unrefresh(reached.key);
                     return false;
@@ -1765,11 +1938,9 @@ export function composeRuntime(options) {
                     ...(landing.remodelled ? { model: reached.model } : {}),
                 }
                 : reached;
-            adoptModels(room.locator, record);
-            const queue = prior?.queue ?? queuesWithoutReplica.get(room.locator) ?? [];
             let set;
             try {
-                set = await settle(local, room.locator, prior, record, queue, landing.kind === 'refreshed'
+                set = await settle(local, room.locator, work, record, work.queue, landing.kind === 'refreshed'
                     ? {
                         room: true,
                         view: 'refreshed',
@@ -1791,14 +1962,16 @@ export function composeRuntime(options) {
                 return true;
             }
             if (landing.kind === 'bootstrapped') {
+                readied(room.locator);
                 highest.delete(room.locator);
                 beyondHorizon.delete(room.locator);
                 untransferred(room.locator);
                 startedOver.delete(room.locator);
                 catching.delete(room.locator);
+                unheldModels.delete(room.locator);
                 if (prior !== undefined && prior.record.key !== record.key)
                     sweep();
-                name(room.locator);
+                void name(room.locator);
             }
             stale.delete(room.locator);
             unpreparable.delete(room.locator);
@@ -1807,28 +1980,27 @@ export function composeRuntime(options) {
             list(room, true);
             publishChangeSet(set);
             await unpair(local);
-            moveTo({ ...status, ...attention() });
-            if (landing.kind === 'bootstrapped' && (replicas.get(room.locator)?.queue.length ?? 0) > 0) {
+            moveTo(status);
+            if (landing.kind === 'bootstrapped' && work.queue.length > 0)
                 submitLater(room.locator);
-            }
             return true;
         });
         return landing.kind === 'refreshed' ? landed : landed.finally(() => installed(room.locator));
     }
     async function savedRoom(locator) {
         const local = await openLocal();
-        const replica = replicas.get(locator);
-        const room = rooms.get(locator);
-        if (replica === undefined || room === undefined) {
+        const replica = await replicaOf(locator);
+        if (replica === undefined || isFenced(locator)) {
             throw runtimeError('unknown-room', `Unknown Room ${locator}`);
         }
-        return { local, replica, room };
+        return { local, replica };
     }
     async function saveRoomDrafts(locator, named, writtenBy) {
         const target = await savedRoom(locator);
+        const drafts = new Map((await draftsOf(locator, named.map(({ path }) => path))).map((record) => [record.path, record]));
         const saved = [];
         for (const { path, revision } of named) {
-            const record = roomDrafts.get(locator)?.get(path);
+            const record = drafts.get(path);
             if (record === undefined || record.revision !== revision) {
                 return { outcome: 'refused', code: 'stale', retryable: false, file: path };
             }
@@ -1855,14 +2027,16 @@ export function composeRuntime(options) {
         }
         return committed(locator, target, saved, new Set(), writtenBy, files);
     }
-    function carriedDrafts(locator, saved, consumed) {
-        const holding = roomDrafts.get(locator);
+    async function carriedDrafts(locator, saved, consumed) {
+        if (!saved.some(({ parts }) => parts.move !== undefined))
+            return new Map();
+        const holding = new Map((await draftsOf(locator)).map((record) => [record.path, record]));
         return new Map(saved.flatMap(({ path, parts }) => {
-            const record = holding?.get(path);
+            const record = holding.get(path);
             if (parts.move === undefined || record === undefined || consumed.has(path))
                 return [];
             const to = moveTarget(parts.move);
-            if (to === path || holding?.has(to) === true)
+            if (to === path || holding.has(to))
                 return [];
             return [[path, { ...record, path: to, revision: roomDraftRevision() }]];
         }));
@@ -1977,15 +2151,15 @@ export function composeRuntime(options) {
             ...new Set((await local.referrers(key, view, targets)).map(({ path }) => path)),
         ];
     }
-    async function sideOf(locator, replica, room, saving) {
+    async function sideOf(locator, replica, saving) {
         const record = replica.record;
         return {
             room: locator,
-            handle: room.handle,
+            handle: record.handle,
             baseRoomVersion: record.roomVersion,
             composition: compositionFor(record),
-            operations: room.operations,
-            providerOwnedPaths: room.providerOwnedPaths,
+            operations: record.operations,
+            providerOwnedPaths: record.providerOwnedPaths,
             visible: saving.visible,
             folders: saving.folders,
             queued: queuedDocuments(replica.queue),
@@ -1998,12 +2172,10 @@ export function composeRuntime(options) {
         return into?.parts.move?.room ?? null;
     }
     async function saveCommit(local, files, rooms) {
-        const touched = new Map();
         const commits = [];
         for (const { locator, saving, before, queue } of rooms) {
             const replayedLayer = await replayed(saving.record, saving.confirmed, queue);
             const diff = await overlayDiff(saving.record, before, replayedLayer.visible, replayedLayer.touched);
-            touched.set(locator, diff.touched);
             commits.push({
                 locator,
                 key: saving.record.key,
@@ -2013,27 +2185,18 @@ export function composeRuntime(options) {
             });
         }
         try {
-            const answer = await local.commit({
+            return await local.commit({
                 rooms: commits,
                 writes: rooms.map(({ write }) => write),
                 files,
                 whole: true,
             });
-            return { answer, touched };
         }
         catch {
             return null;
         }
     }
-    function savedReplica(locator, before, queue, touched, answer) {
-        replicas.set(locator, {
-            ...before,
-            queue,
-            overlaid: touched,
-            count: answer.counts[locator] ?? before.count,
-        });
-    }
-    async function committedMove(locator, destination, { local, replica, room }, saved, consumed, writtenBy, files) {
+    async function committedMove(locator, destination, { local, replica }, saved, consumed, writtenBy, files) {
         const mixed = saved.find(({ parts }) => Object.keys(parts).length !== 1 || parts.move?.room !== destination);
         if (mixed !== undefined) {
             return { outcome: 'refused', code: 'mixed-room-move', retryable: false, file: mixed.path };
@@ -2043,27 +2206,28 @@ export function composeRuntime(options) {
         const changed = saved.flatMap(({ path, parts }) => changedParts(path, parts, sourceSaving.visible));
         if (changed.length > 0)
             return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
-        const target = replicas.get(destination);
-        const listedRoom = rooms.get(destination);
-        if (target === undefined || listedRoom === undefined) {
+        const target = await replicaOf(destination);
+        if (target === undefined || isFenced(destination)) {
             throw runtimeError('unknown-room', `Unknown Room ${destination}`);
         }
         const arriving = await savingIn(target, [], moves.map(({ to }) => to));
         const built = await buildMove({
-            source: await sideOf(locator, replica, room, sourceSaving),
-            destination: await sideOf(destination, target, listedRoom, arriving),
+            source: await sideOf(locator, replica, sourceSaving),
+            destination: await sideOf(destination, target, arriving),
             moves,
-            providerLimits: limits,
+            providerLimits: (await local.facts()).providerLimits,
             local: localSaves,
             ...(writtenBy === undefined ? {} : { writtenBy }),
         });
         if (built.kind === 'refused')
             return { outcome: 'refused', ...built.refusal };
         const id = built.leaving.id;
+        const leavingDrafts = new Map((await draftsOf(locator, saved.map(({ path }) => path))).map((record) => [record.path, record]));
+        const arrivingDrafts = new Set((await draftsOf(destination, moves.map(({ to }) => to))).map(({ path }) => path));
         const carrying = saved.flatMap(({ path, parts }) => {
-            const record = roomDrafts.get(locator)?.get(path);
+            const record = leavingDrafts.get(path);
             const to = moveTarget(parts.move);
-            if (record === undefined || consumed.has(path) || roomDrafts.get(destination)?.has(to)) {
+            if (record === undefined || consumed.has(path) || arrivingDrafts.has(to)) {
                 return [];
             }
             const moved = {
@@ -2079,7 +2243,7 @@ export function composeRuntime(options) {
         const left = [...consumed, ...carrying.map(({ from }) => from)];
         const leavingQueue = [...replica.queue, built.leaving];
         const arrivingQueue = [...target.queue, built.arriving];
-        const committedBoth = await saveCommit(local, files, [
+        const answer = await saveCommit(local, files, [
             {
                 locator,
                 saving: sourceSaving,
@@ -2088,6 +2252,7 @@ export function composeRuntime(options) {
                 write: {
                     locator,
                     queue: leavingQueue,
+                    stored: replica.queue,
                     saved: new Map([[id, saved]]),
                     consumedRoomDrafts: left,
                 },
@@ -2100,37 +2265,23 @@ export function composeRuntime(options) {
                 write: {
                     locator: destination,
                     queue: arrivingQueue,
+                    stored: target.queue,
                     saved: new Map([[id, marked]]),
                     roomDrafts: carried,
                 },
             },
         ]);
-        if (committedBoth === null)
+        if (answer === null)
             return { outcome: 'refused', code: 'durable-write', retryable: true };
-        const { answer, touched } = committedBoth;
         if (answer.fenced !== null) {
             throw runtimeError('unknown-room', `Unknown Room ${answer.fenced}`);
         }
-        if (fences.has(locator) || fences.has(destination)) {
+        if (isFenced(locator) || isFenced(destination)) {
             throw runtimeError('unknown-room', `Unknown Room ${locator}`);
         }
-        pendings.set(pendingKey(locator, id), {
-            drafts: saved,
-            submission: { state: 'waiting' },
-            lost: false,
-        });
-        pendings.set(pendingKey(destination, id), {
-            drafts: marked,
-            submission: { state: 'waiting' },
-            lost: false,
-        });
-        for (const path of left)
-            forgetRoomDraft(locator, path);
-        for (const record of carried)
-            rememberRoomDraft(record);
-        savedReplica(locator, replica, leavingQueue, touched.get(locator), answer);
-        savedReplica(destination, target, arrivingQueue, touched.get(destination), answer);
-        publishChangeSet(mergeChangeSets([
+        preparedAfter(locator, answer);
+        preparedAfter(destination, answer);
+        const shownNow = publishChangeSet(mergeChangeSets([
             changeSet(locator, {
                 documents: answer.changed[locator] ?? [],
                 queue: true,
@@ -2142,14 +2293,15 @@ export function composeRuntime(options) {
                 drafts: carried.map(({ path }) => path),
             }),
         ]));
-        queuedSave(locator);
+        await Promise.all([shownNow, queuedSave(locator)]);
         return { outcome: 'saved', identifier: id };
     }
     function queuedSave(locator) {
         if (!localSaves)
             recorded = false;
-        moveTo({ ...(localSaves ? status : saving(status)), ...attention() });
+        const shownNow = moveTo(localSaves ? status : { ...status, state: 'pending', resting: false });
         submitLater(locator);
+        return shownNow;
     }
     async function committed(locator, target, saved, consumed, writtenBy, files = []) {
         if (full)
@@ -2158,7 +2310,8 @@ export function composeRuntime(options) {
         if (into !== null) {
             return committedMove(locator, into, target, saved, consumed, writtenBy, files);
         }
-        const { local, replica, room } = target;
+        const { local, replica } = target;
+        const { providerLimits } = await local.facts();
         const parts = saved.map(({ path, parts: held }) => changesOf(path, held));
         const changes = parts.flatMap(({ changes: made }) => made);
         const saving = await savingIn(replica, changes, [
@@ -2168,7 +2321,7 @@ export function composeRuntime(options) {
         const changed = saved.flatMap(({ path, parts: held }) => changedParts(path, held, saving.visible));
         if (changed.length > 0)
             return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
-        const requeue = await stepped(requeuing(replica.queue, changes, saving.visible, withdrawable(locator), saving.visibleOver));
+        const requeue = await stepped(requeuing(replica.queue, changes, saving.visible, withdrawable(replica.states), saving.visibleOver));
         if (requeue.kind === 'refused')
             return { outcome: 'refused', ...requeue.refusal };
         const foreign = [...requeue.withdrawn.keys()].some((origin) => {
@@ -2188,10 +2341,10 @@ export function composeRuntime(options) {
             local: localSaves,
             baseRoomVersion: replica.record.roomVersion,
             composition: compositionFor(replica.record),
-            operations: room.operations,
-            providerOwnedPaths: room.providerOwnedPaths,
-            providerLimits: limits,
-            handle: room.handle,
+            operations: replica.record.operations,
+            providerOwnedPaths: replica.record.providerOwnedPaths,
+            providerLimits,
+            handle: replica.record.handle,
             visible: saving.visible,
             folders: saving.folders,
             changes,
@@ -2243,7 +2396,7 @@ export function composeRuntime(options) {
         for (const [origin, replaced] of withdrawn) {
             if (replaced === null)
                 continue;
-            const carried = withdrawnDrafts(pendings.get(pendingKey(locator, origin))?.drafts ?? [], changes);
+            const carried = withdrawnDrafts(replica.states.get(origin)?.drafts ?? [], changes);
             drafted.set(replaced.id, replaced === join?.batch
                 ? [
                     ...carried.map((held) => joinedDraft(held, saved)),
@@ -2257,14 +2410,14 @@ export function composeRuntime(options) {
         for (const replaced of withdrawn.values()) {
             if (replaced === null || !batches.includes(replaced))
                 continue;
-            const limited = await stepped(limiting(batches, replaced, limits, saving.visibleOver));
+            const limited = await stepped(limiting(batches, replaced, providerLimits, saving.visibleOver));
             if (limited !== null)
                 return { outcome: 'refused', ...limited };
         }
-        const carried = carriedDrafts(locator, saved, consumed);
+        const carried = await carriedDrafts(locator, saved, consumed);
         const left = [...consumed, ...carried.keys()];
         const arrived = [...carried.values()];
-        const done = await saveCommit(local, files, [
+        const answer = await saveCommit(local, files, [
             {
                 locator,
                 saving,
@@ -2273,40 +2426,27 @@ export function composeRuntime(options) {
                 write: {
                     locator,
                     queue: batches,
+                    stored: replica.queue,
                     saved: drafted,
                     consumedRoomDrafts: left,
                     roomDrafts: arrived,
                 },
             },
         ]);
-        if (done === null)
+        if (answer === null)
             return { outcome: 'refused', code: 'durable-write', retryable: true };
-        const { answer, touched } = done;
         if (answer.fenced !== null) {
             throw runtimeError('unknown-room', `Unknown Room ${answer.fenced}`);
         }
-        if (fences.has(locator))
+        if (isFenced(locator))
             throw runtimeError('unknown-room', `Unknown Room ${locator}`);
-        for (const origin of withdrawn.keys())
-            pendings.delete(pendingKey(locator, origin));
-        for (const [id, drafts] of drafted) {
-            pendings.set(pendingKey(locator, id), {
-                drafts,
-                submission: { state: 'waiting' },
-                lost: false,
-            });
-        }
-        for (const path of left)
-            forgetRoomDraft(locator, path);
-        for (const record of arrived)
-            rememberRoomDraft(record);
-        savedReplica(locator, replica, batches, touched.get(locator), answer);
-        publishChangeSet(changeSet(locator, {
+        preparedAfter(locator, answer);
+        const shownNow = publishChangeSet(changeSet(locator, {
             documents: answer.changed[locator] ?? [],
             queue: true,
             drafts: [...left, ...arrived.map(({ path }) => path)],
         }));
-        queuedSave(locator);
+        await Promise.all([shownNow, queuedSave(locator)]);
         const identifier = join?.batch.id ??
             built?.batch.id ??
             [...requeue.withdrawn].map(([origin, replaced]) => replaced?.id ?? origin).at(-1);
@@ -2315,29 +2455,26 @@ export function composeRuntime(options) {
     async function mark(local, locator, batch, submission, lost) {
         const partner = partnerOf(batch, locator);
         for (const held of partner === null ? [locator] : [locator, partner]) {
-            const state = pendings.get(pendingKey(held, batch.id));
+            const { state, room } = await local.pending(held, batch.id);
             if (!continuing() ||
                 state === undefined ||
                 (JSON.stringify(state.submission) === JSON.stringify(submission) && state.lost === lost)) {
                 continue;
             }
             await local.submit(held, batch.id, submission, lost);
-            if (fences.has(held))
+            if (isFenced(held))
                 continue;
-            pendings.set(pendingKey(held, batch.id), { ...state, submission, lost });
-            if (replicas.has(held))
+            if (room)
                 publishChangeSet(changeSet(held, { queue: true }));
         }
-        moveTo({ ...status, ...attention() });
+        moveTo(status);
     }
     async function keepUpload(local, locator, identifier, upload) {
         if (!continuing())
             throw new Error('connection refused');
         await local.keepUpload(locator, identifier, upload);
-        if (fences.has(locator))
+        if (isFenced(locator))
             throw runtimeError('unknown-room', `Unknown Room ${locator}`);
-        const key = pendingKey(locator, identifier);
-        pendings.set(key, { ...pendings.get(key), upload });
         if (!continuing())
             throw new Error('connection refused');
     }
@@ -2373,7 +2510,7 @@ export function composeRuntime(options) {
             if (fencedSince(locator, since))
                 return failure({ kind: 'room-not-readable', locator });
             if (result.kind === 'scoped-refusal') {
-                const room = replicas.get(result.locator)?.record;
+                const room = await recordAt(result.locator);
                 if (room !== undefined)
                     await scoped(result, room, await openLocal());
             }
@@ -2386,27 +2523,28 @@ export function composeRuntime(options) {
             return UNCERTAIN;
         }
     }
-    function located(room, path, destination) {
+    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 || !rooms.has(room) ? null : { room, path: named };
+            return named === null || !listing.has(room) ? null : { room, path: named };
         }
-        const held = [...rooms.values()].find((listed) => listed.handle === crossing.handle);
+        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 = located(room, path, destination);
+        const at = await located(room, path, destination);
         if (at === null)
             return UNREADABLE;
-        if (locked(at.room))
+        if (await locked(at.room))
             return LOCKED_UNREADABLE;
-        const held = replicas.get(at.room);
+        const held = await recordAt(at.room);
         if (held !== undefined &&
-            (await (await openLocal()).entries(held.record.key, 'visible', [at.path])).length > 0) {
+            (await (await openLocal()).entries(held.key, 'visible', [at.path])).length > 0) {
             return { kind: 'document', ...at };
         }
         const history = await readHistory(at.room, at.path);
@@ -2421,13 +2559,13 @@ export function composeRuntime(options) {
             ? { kind: 'deleted', ...at, revision: last }
             : { kind: 'document', ...at };
     }
-    function queuedFacts(locator, path, localId) {
-        for (const batch of replicas.get(locator)?.queue ?? []) {
+    async function queuedFacts(locator, path, localId) {
+        for (const batch of (await replicaOf(locator))?.queue ?? []) {
             const change = batch.changes[queuedFile(batch, path, localId)];
             if (change?.kind === 'binary')
                 return change;
         }
-        const drafted = roomDrafts.get(locator)?.get(path)?.parts.file;
+        const drafted = (await draftOf(locator, path))?.parts.file;
         return drafted?.localId === localId ? drafted : null;
     }
     function batchFile(batch) {
@@ -2459,7 +2597,7 @@ export function composeRuntime(options) {
             if (fencedSince(request.locator, since))
                 return failure({ kind: 'room-not-readable', locator: request.locator });
             if (settled.kind === 'scoped-refusal') {
-                const room = replicas.get(settled.locator)?.record;
+                const room = await recordAt(settled.locator);
                 if (room !== undefined)
                     await scoped(settled, room, await openLocal());
             }
@@ -2486,7 +2624,7 @@ export function composeRuntime(options) {
     async function binaryPath(locator, path, revision) {
         if (revision !== undefined)
             return { kind: 'path', locator, path, revision };
-        const replica = replicas.get(locator);
+        const replica = await replicaOf(locator);
         const local = await openLocal();
         const [held] = replica === undefined ? [] : await local.entries(replica.record.key, 'visible', [path]);
         const attached = held === undefined ? attachedFiles.get(locator)?.get(path) : undefined;
@@ -2526,13 +2664,13 @@ export function composeRuntime(options) {
     }
     async function askedBinary(locator, path, revision) {
         await ready;
-        const drafted = roomDrafts.get(locator)?.get(path)?.parts.file;
+        const drafted = (await draftOf(locator, path))?.parts.file;
         return drafted !== undefined && drafted.localId === revision
             ? { kind: 'pending', localId: revision }
             : binaryPath(locator, path, revision);
     }
-    function pendingBinary(locator, path, localId) {
-        const facts = queuedFacts(locator, path, localId);
+    async function pendingBinary(locator, path, localId) {
+        const facts = await queuedFacts(locator, path, localId);
         return facts === null
             ? absentBinary(path)
             : {
@@ -2551,10 +2689,10 @@ export function composeRuntime(options) {
         return readBinary(asked, { locator, path: asked.path, revision: asked.revision });
     }
     async function heldMediaType(locator, path) {
-        const replica = replicas.get(locator);
+        const replica = await recordAt(locator);
         const [held] = replica === undefined
             ? []
-            : await (await openLocal()).entries(replica.record.key, 'visible', [path]);
+            : await (await openLocal()).entries(replica.key, 'visible', [path]);
         return held === undefined
             ? attachedFiles.get(locator)?.get(path)?.mediaType
             : held.binary?.mediaType;
@@ -2589,7 +2727,7 @@ export function composeRuntime(options) {
     async function attachBinary(locator, file) {
         await ready;
         await firstDiscovery;
-        if (closed || !roomsNamed || connectionOf() === 'unreachable' || refusal !== null)
+        if (closed || !roomsNamed || (await connectionNow()) === 'unreachable' || refusal !== null)
             return OFFLINE;
         const request = await attachedFile(locator, file);
         return transferBinary({ locator, path: file.name }, async (held) => {
@@ -2609,8 +2747,8 @@ export function composeRuntime(options) {
         const freed = await database.ask({ kind: 'opened.clean' });
         return freed + ((await options.shell.cleanUp?.()) ?? 0);
     }
-    function declaredAction(name) {
-        for (const capability of capabilities) {
+    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;
@@ -2618,8 +2756,8 @@ export function composeRuntime(options) {
         }
         return undefined;
     }
-    function calledRooms(name, input) {
-        const member = declaredAction(name)?.room;
+    async function calledRooms(name, input) {
+        const member = (await declaredAction(name))?.room;
         if (member === undefined || input === null || typeof input !== 'object')
             return [];
         const named = input[member];
@@ -2629,7 +2767,7 @@ export function composeRuntime(options) {
         await ready;
         if (closed || refusal !== null)
             return UNCERTAIN;
-        if (declaredAction(name) === undefined)
+        if ((await declaredAction(name)) === undefined)
             return undeclared(name);
         try {
             await ensureAuthorization();
@@ -2644,7 +2782,7 @@ export function composeRuntime(options) {
         try {
             const result = await options.adapter.action(authorization, { name, input });
             if (result.kind === 'scoped-refusal') {
-                const room = replicas.get(result.locator)?.record;
+                const room = await recordAt(result.locator);
                 if (room !== undefined)
                     await scoped(result, room, await openLocal());
             }
@@ -2731,31 +2869,35 @@ export function composeRuntime(options) {
     function continuing() {
         return !closed && !discoveryPaused;
     }
-    function reachedBy(locator, roomVersion) {
-        const held = replicas.get(locator);
-        return (held !== undefined && options.adapter.reached(locator, held.record.roomVersion, roomVersion));
+    async function reachedBy(locator, roomVersion) {
+        const held = await recordAt(locator);
+        return held !== undefined && options.adapter.reached(locator, held.roomVersion, roomVersion);
     }
-    function shownAt(locator) {
-        const held = replicas.get(locator)?.record.roomVersion;
+    function shownAt(locator, held) {
         const raised = highest.get(locator);
         if (held === undefined || raised === undefined)
             return held ?? raised;
         return options.adapter.reached(locator, held, raised) ? held : raised;
     }
-    function showing(locator, roomVersion) {
-        const at = shownAt(locator);
+    function showing(locator, roomVersion, held) {
+        const at = shownAt(locator, held);
         if (at === undefined || !options.adapter.reached(locator, at, roomVersion)) {
             highest.set(locator, roomVersion);
         }
     }
-    function older(locator, roomVersion) {
+    function olderThan(locator, roomVersion, held) {
         if (beyondHorizon.has(locator))
             return false;
-        const at = shownAt(locator);
+        const at = shownAt(locator, held);
         return (at !== undefined &&
             options.adapter.reached(locator, at, roomVersion) &&
             !options.adapter.reached(locator, roomVersion, at));
     }
+    async function older(locator, roomVersion) {
+        if (beyondHorizon.has(locator))
+            return false;
+        return olderThan(locator, roomVersion, (await recordAt(locator))?.roomVersion);
+    }
     function replaced(locators) {
         for (const locator of locators) {
             highest.delete(locator);
@@ -2763,17 +2905,22 @@ export function composeRuntime(options) {
         }
     }
     async function writtenAfter(locator, roomVersion, path) {
-        const held = replicas.get(locator);
+        const held = await recordAt(locator);
         if (held === undefined)
             return false;
-        const [entry] = await (await openLocal()).entries(held.record.key, 'confirmed', [path]);
+        const [entry] = await (await openLocal()).entries(held.key, 'confirmed', [path]);
         const written = entry?.written ?? undefined;
         return (written !== undefined &&
             options.adapter.reached(locator, written, roomVersion) &&
             !options.adapter.reached(locator, roomVersion, written));
     }
-    async function writtenLater(local, locator, key, paths, roomVersion) {
-        if (paths.length === 0 || !older(locator, roomVersion))
+    async function writtenLater(local, locator, key, paths, roomVersion, heldAt) {
+        if (paths.length === 0)
+            return new Set();
+        const behindShown = heldAt === undefined
+            ? await older(locator, roomVersion)
+            : olderThan(locator, roomVersion, heldAt);
+        if (!behindShown)
             return new Set();
         const entries = await local.entries(key, 'confirmed', paths);
         return new Set(entries.flatMap(({ path, written }) => written !== null &&
@@ -2782,7 +2929,7 @@ export function composeRuntime(options) {
             ? [path]
             : []));
     }
-    function refreshingOf(local, locator, key, composition, liveness, replaying = false) {
+    function refreshingOf(local, locator, key, composition, liveness, replaying = false, heldAt) {
         const write = replaying ? finishingWrite : exclusive;
         return {
             turn() {
@@ -2790,7 +2937,7 @@ export function composeRuntime(options) {
                     installing(locator);
             },
             prior: async (paths) => new Map((await local.entries(key, 'refreshed', paths)).map((entry) => [entry.path, entry])),
-            later: (paths, roomVersion) => writtenLater(local, locator, key, paths, roomVersion),
+            later: (paths, roomVersion) => writtenLater(local, locator, key, paths, roomVersion, heldAt),
             async stage(page) {
                 for (let written = 0;;) {
                     const end = batchEnd(page.entries, written);
@@ -2928,7 +3075,7 @@ export function composeRuntime(options) {
         unindexed.delete(locator);
     }
     function setBack(locator) {
-        const now = bytesOf(locator, true);
+        const now = bytesOf(locator, true, new Map());
         const earlier = startedOver.get(locator);
         startedOver.set(locator, {
             done: Math.max(now.done, earlier?.done ?? 0),
@@ -2964,11 +3111,13 @@ export function composeRuntime(options) {
         if (installs.delete(locator))
             queueReadiness();
     }
-    async function pullRefresh(authorized, held, liveness, hold, refresh) {
+    async function pullRefresh(authorized, record, liveness, hold, refresh) {
         if (!liveness())
             return unconfirmed;
-        const { record } = held;
-        const from = standingOf(record.locator);
+        const from = {
+            key: record.key,
+            confirmed: confirmations.get(record.locator) ?? 0,
+        };
         const local = await openLocal();
         try {
             await exclusive(() => local.unrefresh(record.key));
@@ -2980,7 +3129,7 @@ export function composeRuntime(options) {
                 finally {
                     hold.take();
                 }
-            }, authorized, record, (models, kept) => (liveness() ? remodel(record.locator, models, kept) : kept), liveness, refreshingOf(local, record.locator, record.key, composed(record), liveness));
+            }, authorized, record, (models, kept) => (liveness() ? remodel(models, kept) : kept), liveness, refreshingOf(local, record.locator, record.key, composed(record), liveness, false, record.roomVersion));
             if (result.kind !== 'advanced') {
                 journal.record(`transfer refresh ${record.locator} ${result.kind}`);
                 return result;
@@ -3000,30 +3149,14 @@ export function composeRuntime(options) {
             throw error;
         }
     }
-    const heldContents = new Map();
-    function heldContentOf(local, key) {
-        const known = heldContents.get(key);
-        if (known !== undefined)
-            return known;
-        if (heldContents.size > ROOM_READS)
-            heldContents.clear();
-        const made = {
-            files: (after, limit) => local.files(key, 'confirmed', after, limit),
-            async contents(paths) {
-                return new Map((await local.entries(key, 'confirmed', paths)).flatMap(({ path, content, revision }) => content === null || revision === null ? [] : [[path, { content, revision }]]));
-            },
-        };
-        heldContents.set(key, made);
-        return made;
-    }
     async function abandoned(local, locator) {
         await local.abandon(locator);
         setBack(locator);
         untransferred(locator);
-        liveQueries.recover();
+        recoverReads();
         sweep();
     }
-    function staging(local, liveness) {
+    function staging(local, liveness, unheld) {
         const derived = async (locator, key, composition) => {
             underived.delete(locator);
             for (;;) {
@@ -3093,9 +3226,9 @@ export function composeRuntime(options) {
                 const held = { ...record, key };
                 transfers.set(locator, held);
                 if (arrived)
-                    liveQueries.recover();
+                    recoverReads();
                 installing(locator);
-                liveQueries.recover();
+                recoverReads();
                 const text = page.entries.reduce((sum, entry) => sum + (entry.content?.length ?? 0), 0);
                 owedIndexes(locator, record.done.bytes - prior, text);
                 const owed = text + (underived.get(locator) ?? 0);
@@ -3104,6 +3237,37 @@ export function composeRuntime(options) {
                     return held;
                 return (await derived(locator, key, composition)) ? held : null;
             },
+            async resume(record, parts, composition) {
+                const { locator } = record;
+                installing(locator);
+                if (!liveness())
+                    return null;
+                const prior = unheld === undefined ? await recordAt(locator) : undefined;
+                const published = prior !== undefined && prior.replica.selection === record.selection ? prior.key : null;
+                const kept = unheld?.staged ?? (await local.held()).staged.has(locator);
+                if (published === null && !kept)
+                    return { record: null, staged: new Set() };
+                const resumed = await installWrite(async () => {
+                    if (!liveness())
+                        return null;
+                    return local.resume(record, composition, parts.map((part) => part.id), published);
+                });
+                if (resumed === null || !liveness())
+                    return null;
+                const parted = new Set(resumed.staged);
+                if (resumed.key === null)
+                    return { record: null, staged: parted };
+                const bytes = parts.reduce((sum, part) => sum + (parted.has(part.id) ? part.bytes : 0), 0);
+                const held = {
+                    ...record,
+                    transfer: resumed.transfer,
+                    key: resumed.key,
+                    done: { bytes },
+                };
+                transfers.set(locator, held);
+                recoverReads();
+                return { record: held, staged: parted };
+            },
             derive: derived,
             async refreshing(locator, key, composition) {
                 await exclusive(() => local.unrefresh(key));
@@ -3118,33 +3282,26 @@ export function composeRuntime(options) {
                     return;
                 setBack(locator);
                 untransferred(locator);
-                liveQueries.recover();
+                recoverReads();
             },
             release: (key) => exclusive(async () => {
                 await local.release(key);
                 sweep();
             }),
-            content: (key) => heldContentOf(local, key),
         };
     }
-    function reusable(room, local) {
-        const record = replicas.get(room.locator)?.record;
-        if (record === undefined || record.replica.selection !== room.replica.selection)
-            return null;
-        return heldContentOf(local, record.key);
-    }
-    async function pullBootstrap(authorized, room, local, liveness) {
+    async function pullBootstrap(authorized, room, local, liveness, prior, from = reads, unheld) {
         if (!liveness())
             return unconfirmed;
-        if (replicas.has(room.locator)) {
+        if (prior !== undefined) {
             catching.add(room.locator);
-            liveQueries.recover();
+            recoverReads();
         }
         try {
-            const result = await bootstrapRoom(reads, authorized, room, { collection: modelOf(room.locator) }, builtIn, typedPaths, (models, held) => (liveness() ? remodel(room.locator, models, held) : held), liveness, staging(local, liveness), reusable(room, local));
+            const result = await bootstrapRoom(from, authorized, room, { collection: prior?.model ?? unheldModels.get(room.locator) ?? NO_MODEL }, builtIn, typedPaths, (models, held) => (liveness() ? remodel(models, held) : held), liveness, staging(local, liveness, unheld));
             const detail = result.kind === 'staged' ? result.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
-            if (result.kind === 'staged' && older(room.locator, result.record.roomVersion)) {
+            if (result.kind === 'staged' && (await older(room.locator, result.record.roomVersion))) {
                 caughtUpTo(room.locator);
                 installed(room.locator);
                 await abandoned(local, room.locator);
@@ -3168,28 +3325,31 @@ export function composeRuntime(options) {
     }
     function caughtUpTo(locator) {
         if (catching.delete(locator))
-            liveQueries.recover();
+            recoverReads();
     }
-    function behind(room) {
-        const held = replicas.get(room.locator)?.record.roomVersion;
+    async function behind(room) {
+        const held = (await recordAt(room.locator))?.roomVersion;
         return held !== undefined && !options.adapter.reached(room.locator, held, room.roomVersion);
     }
-    function standingOf(locator) {
-        const held = replicas.get(locator);
-        return { key: held?.record.key ?? null, confirmed: held?.confirmed ?? 0 };
+    function standingFrom(locator, held) {
+        return { key: held?.record.key ?? null, confirmed: confirmations.get(locator) ?? 0 };
+    }
+    function standingAt(locator, held) {
+        return { key: held?.key ?? null, confirmed: confirmations.get(locator) ?? 0 };
     }
-    function stands(locator, from) {
-        const now = standingOf(locator);
+    function standsAt(locator, held, from) {
+        const now = standingFrom(locator, held);
         return now.key === from.key && now.confirmed === from.confirmed;
     }
-    async function advance(room, local, authorized, running) {
+    async function advance(room, local, authorized, running, unheld) {
         const live = () => running() && !full;
         if (!live())
             return unconfirmed;
-        const held = replicas.get(room.locator);
-        if (held !== undefined && options.adapter.roomStream !== undefined) {
+        const held = unheld === undefined ? await recordAt(room.locator) : undefined;
+        if (options.adapter.roomStream !== undefined &&
+            (held !== undefined || !beyondHorizon.has(room.locator))) {
             stale.delete(room.locator);
-            name(room.locator);
+            await name(room.locator);
             return null;
         }
         const refresh = reads.refresh;
@@ -3203,15 +3363,16 @@ export function composeRuntime(options) {
                 return unconfirmed;
             replaced([room.locator]);
         }
-        const from = standingOf(room.locator);
-        const bootstrapped = await pullBootstrap(authorized, room, local, live);
+        const prior = held === undefined ? undefined : await recordAt(room.locator);
+        const from = standingAt(room.locator, prior);
+        const bootstrapped = await pullBootstrap(authorized, room, local, live, prior, reads, unheld);
         if (bootstrapped.kind !== 'staged')
             return live() ? bootstrapped : unconfirmed;
         const landing = { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from };
         if (await publish(local, room, bootstrapped.record, landing, live)) {
             return live() ? null : unconfirmed;
         }
-        return reachedBy(room.locator, bootstrapped.record.roomVersion)
+        return (await reachedBy(room.locator, bootstrapped.record.roomVersion))
             ? null
             : advance(room, local, authorized, live);
     }
@@ -3235,12 +3396,12 @@ export function composeRuntime(options) {
                 remodelled: refreshed.remodelled,
             };
             if (!(await publish(local, room, refreshed.record, landing, live))) {
-                const now = replicas.get(room.locator)?.record.roomVersion;
+                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, modelOf(room.locator));
+            await retainModel(local, room, null);
             return null;
         }
         return refreshed.kind === 'beyond-horizon' ? 'beyond-horizon' : refreshed;
@@ -3248,6 +3409,11 @@ export function composeRuntime(options) {
     async function withhold(withheld, room, local, progress) {
         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;
@@ -3274,6 +3440,37 @@ export function composeRuntime(options) {
             await refuse('revoked-authorization');
         }
     }
+    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 && !socketOpen) || 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 leaving(batch, result) {
         return {
             batch,
@@ -3299,7 +3496,8 @@ export function composeRuntime(options) {
     async function acceptance(room, local, submitted, accepted) {
         if (!continuing())
             return unconfirmed;
-        const current = replicas.get(room.locator);
+        const work = await workOf(room.locator);
+        const current = work.replica;
         if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
             return null;
         }
@@ -3308,7 +3506,7 @@ export function composeRuntime(options) {
         let record = current.record;
         let changes;
         if (!options.adapter.reached(room.locator, held, accepted.roomVersion) &&
-            !older(room.locator, accepted.roomVersion)) {
+            !olderThan(room.locator, accepted.roomVersion, held)) {
             const paths = [...returnedPaths(submitted, accepted)];
             const confirmedLayer = await stepped(slicing(await local.entries(record.key, 'confirmed', paths), paths));
             const back = await stepped(returning(confirmedLayer, submitted, accepted, accepted.roomVersion, composed(record)));
@@ -3320,13 +3518,13 @@ export function composeRuntime(options) {
             };
             changes = back;
         }
-        const settled = await settlement(local, room.locator, current, record, current.queue.filter((batch) => batch.id !== submitted.id), { room: true, ...(changes === undefined ? {} : { changes }) });
+        const settled = await settlement(local, room.locator, work, record, current.queue.filter((batch) => batch.id !== submitted.id), { room: true, ...(changes === undefined ? {} : { changes }) });
+        const reached = record.roomVersion;
         return {
             ...settled,
             apply(answer) {
                 const set = settled.apply(answer);
-                showing(room.locator, accepted.roomVersion);
-                pendings.delete(pendingKey(room.locator, submitted.id));
+                showing(room.locator, accepted.roomVersion, reached);
                 unreadable.delete(room.locator);
                 list(room, true);
                 return set;
@@ -3336,8 +3534,9 @@ export function composeRuntime(options) {
     async function adoptedTogether(local, acceptances) {
         const settlements = acceptances.filter(settling);
         if (settlements.length > 0) {
-            publishChangeSet(await together(local, settlements));
-            moveTo({ ...status, ...attention() });
+            const set = await together(local, settlements);
+            void moveTo(status);
+            void publishChangeSet(set);
         }
         await unpair(local);
     }
@@ -3353,7 +3552,7 @@ export function composeRuntime(options) {
         const other = discovered.get(partner);
         const failed = await exclusive(async () => {
             const left = await acceptance(room, local, submitted, accepted);
-            const arriving = replicas.get(partner)?.queue.find((batch) => batch.id === submitted.id);
+            const arriving = (await replicaOf(partner))?.queue.find((batch) => batch.id === submitted.id);
             const arrived = other === undefined || arriving === undefined || accepted.destination === undefined
                 ? null
                 : await acceptance(other, local, arriving, {
@@ -3366,25 +3565,24 @@ export function composeRuntime(options) {
         submitLater(partner);
         return failed === null;
     }
-    function queueIn(locator) {
-        return replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? [];
+    async function behindIn(locator, batch) {
+        const local = await openLocal();
+        const [order, { room }] = await Promise.all([
+            local.order(locator),
+            local.pending(locator, batch.id),
+        ]);
+        return room ? order.indexOf(batch.id) > 0 : order.length > 0;
     }
-    function behindIn(locator, batch) {
-        const held = replicas.get(locator)?.queue;
-        if (held === undefined)
-            return queuesWithoutReplica.get(locator) !== undefined;
-        return held.findIndex((one) => one.id === batch.id) > 0;
-    }
-    function unpaired(skipped) {
-        for (const locator of [...replicas.keys(), ...queuesWithoutReplica.keys()]) {
-            for (const batch of queueIn(locator)) {
-                const partner = partnerOf(batch, locator);
-                if (partner === null || skipped.has(pendingKey(locator, batch.id)))
-                    continue;
-                if (queueIn(partner).some((held) => held.id === batch.id))
-                    continue;
-                if (unpairedIn(locator, batch))
-                    return { locator, batch };
+    async function unpaired(local, skipped) {
+        const { queued, moving } = await local.moving();
+        for (const { locator, batch, state } of moving) {
+            const partner = partnerOf(batch, locator);
+            if (partner === null || skipped.has(pendingKey(locator, batch.id)))
+                continue;
+            if (queued.get(partner)?.includes(batch.id) === true)
+                continue;
+            if (!leavingIn(batch, locator) || withdrawable(new Map([[batch.id, state]]))(batch)) {
+                return { locator, batch };
             }
         }
         return null;
@@ -3396,9 +3594,10 @@ export function composeRuntime(options) {
             returned: !localSaves && leavingIn(batch, locator) ? returnedBy('withdrawn') : null,
         }));
         const outcome = localSaves ? 'dropped' : 'unpaired';
-        const current = replicas.get(locator);
+        const work = await workOf(locator);
+        const current = work.replica;
         if (current !== undefined) {
-            const settled = await settlement(local, locator, current, current.record, current.queue.filter((one) => !ids.has(one.id)), { leaving });
+            const settled = await settlement(local, locator, work, current.record, current.queue.filter((one) => !ids.has(one.id)), { leaving });
             return {
                 ...settled,
                 apply(answer) {
@@ -3410,22 +3609,22 @@ export function composeRuntime(options) {
                 },
             };
         }
-        const queue = queueIn(locator).filter((one) => !ids.has(one.id));
+        const queue = work.queue.filter((one) => !ids.has(one.id));
         const written = new Map();
         for (const { batch, returned } of leaving) {
             if (returned === null)
                 continue;
-            for (const saved of pendings.get(pendingKey(locator, batch.id))?.drafts ?? []) {
+            for (const saved of work.states.get(batch.id)?.drafts ?? []) {
                 written.set(saved.path, {
                     locator,
                     path: saved.path,
                     revision: roomDraftRevision(),
-                    parts: returnedInto((written.get(saved.path) ?? roomDrafts.get(locator)?.get(saved.path))?.parts, saved.parts),
+                    parts: returnedInto((written.get(saved.path) ?? (await draftOf(locator, saved.path)))?.parts, saved.parts),
                     returned,
                 });
             }
         }
-        const carried = carriedBack(locator, leaving.flatMap(({ batch, returned }) => (returned === null ? [] : [batch])), written);
+        const carried = await carriedBack(locator, leaving.flatMap(({ batch, returned }) => (returned === null ? [] : [batch])), written);
         return {
             locator,
             left: batches,
@@ -3435,6 +3634,7 @@ export function composeRuntime(options) {
                     {
                         locator,
                         queue,
+                        stored: work.queue,
                         roomDrafts: [...written.values()],
                         consumedRoomDrafts: carried.taken,
                     },
@@ -3442,17 +3642,8 @@ export function composeRuntime(options) {
                 ],
             },
             apply() {
-                for (const batch of batches) {
+                for (const batch of batches)
                     journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
-                    pendings.delete(pendingKey(locator, batch.id));
-                }
-                if (queue.length > 0)
-                    queuesWithoutReplica.set(locator, queue);
-                else
-                    queuesWithoutReplica.delete(locator);
-                for (const record of written.values())
-                    rememberRoomDraft(record);
-                carried.remember();
                 submitLater(locator);
                 return mergeChangeSets([
                     changeSet(locator, {
@@ -3466,28 +3657,33 @@ export function composeRuntime(options) {
     }
     async function unpair(local) {
         const handled = new Set();
-        for (let held = unpaired(handled); held !== null && continuing(); held = unpaired(handled)) {
+        for (let held = await unpaired(local, handled); held !== null && continuing(); held = await unpaired(local, handled)) {
             const { locator, batch } = held;
             handled.add(pendingKey(locator, batch.id));
             publishChangeSet(await together(local, [await unpairing(local, locator, [batch])]));
         }
         if (handled.size === 0)
             return;
-        moveTo({ ...status, ...attention() });
+        moveTo(status);
     }
     async function submitRoom(room, local, authorized, progress, signal) {
         while (continuing() && authorization !== undefined && !signal.aborted) {
-            const replica = replicas.get(room.locator);
-            const head = replica?.queue.find((batch) => !landedAhead.has(pendingKey(room.locator, batch.id)));
-            if (replica === undefined || head === undefined)
+            const headId = (await local.order(room.locator)).find((id) => !landedAhead.has(pendingKey(room.locator, id)));
+            if (headId === undefined)
+                return 'done';
+            const [head, pending] = await Promise.all([
+                local.batch(room.locator, headId),
+                local.pending(room.locator, headId),
+            ]);
+            if (head === null || !pending.room)
                 return 'done';
-            const state = pendings.get(pendingKey(room.locator, head.id));
+            const { state } = pending;
             const partner = partnerOf(head, room.locator);
             if (partner !== null && !leavingIn(head, room.locator)) {
                 submitLater(partner);
                 return 'done';
             }
-            if (partner !== null && behindIn(partner, head)) {
+            if (partner !== null && (await behindIn(partner, head))) {
                 progress.complete = false;
                 return 'done';
             }
@@ -3508,7 +3704,7 @@ export function composeRuntime(options) {
             let result;
             journal.record(`submission ${room.locator} ${head.id}`);
             await exclusive(() => mark(local, room.locator, head, { state: 'submitted' }, lost));
-            if (discoveryPaused || fences.has(room.locator))
+            if (discoveryPaused || isFenced(room.locator))
                 return 'done';
             if (signal.aborted || writesHeld()) {
                 await exclusive(() => mark(local, room.locator, head, submission, earlier));
@@ -3614,7 +3810,8 @@ export function composeRuntime(options) {
                 await exclusive(async () => {
                     if (!continuing())
                         return;
-                    const current = replicas.get(room.locator);
+                    const work = await workOf(room.locator);
+                    const current = work.replica;
                     if (current === undefined || !current.queue.some((batch) => batch.id === head.id)) {
                         return;
                     }
@@ -3628,9 +3825,9 @@ export function composeRuntime(options) {
                         landedAhead.set(pendingKey(room.locator, head.id), Object.fromEntries([...touchedBy([head])].map((path) => [path, confirmedLayer.revisions[path]])));
                         return;
                     }
-                    publishChangeSet(await settle(local, room.locator, current, current.record, current.queue.filter((batch) => batch.id !== head.id), { leaving: [held ? { ...left, returned: null } : left] }));
+                    publishChangeSet(await settle(local, room.locator, work, current.record, current.queue.filter((batch) => batch.id !== head.id), { leaving: [held ? { ...left, returned: null } : left] }));
                     await unpair(local);
-                    moveTo({ ...status, ...attention() });
+                    moveTo(status);
                 });
                 const { there, here } = judged ?? (await refreshed());
                 if (other !== undefined && there !== null)
@@ -3665,24 +3862,24 @@ export function composeRuntime(options) {
             release();
         };
     }
-    function declaredAsHeld(room) {
-        const held = replicas.get(room.locator)?.record;
+    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 = replicas.get(room.locator)?.record;
+        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 replica = replicas.get(room.locator);
-            if (replica === undefined)
+            const current = await recordAt(room.locator);
+            if (current === undefined)
                 return;
-            const record = { ...replica.record, name: room.name, handle: room.handle };
+            const record = { ...current, name: room.name, handle: room.handle };
             await local.commit({
                 rooms: [
                     {
@@ -3693,36 +3890,38 @@ export function composeRuntime(options) {
                     },
                 ],
             });
-            replicas.set(room.locator, { ...replica, record });
+            emitRooms();
         });
     }
-    async function retainModel(local, room, next) {
-        const key = room.locator;
-        const previous = modelOf(room.locator);
-        if (JSON.stringify(previous) === JSON.stringify(next) && declaredAsHeld(room))
+    async function modelNow(locator) {
+        return (await recordAt(locator))?.model ?? unheldModels.get(locator) ?? NO_MODEL;
+    }
+    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;
-            const held = replicas.get(room.locator);
+            const work = await workOf(room.locator);
+            const current = work.replica;
             let changed = null;
-            if (held !== undefined) {
+            if (current !== undefined) {
                 const record = {
-                    ...held.record,
+                    ...current.record,
                     name: room.name,
                     handle: room.handle,
                     operations: room.operations,
                     replica: room.replica,
+                    providerOwnedPaths: room.providerOwnedPaths,
                     typedSelection: room.typedSelection ?? null,
                     model: next,
                 };
-                const confirmedLayer = await sliceAt(record, 'confirmed', held.queue, held.overlaid);
-                const replayedLayer = await replayed(record, confirmedLayer, held.queue);
-                const diff = await overlayDiff(record, held, replayedLayer.visible, replayedLayer.touched);
+                const confirmedLayer = await sliceAt(record, 'confirmed', current.queue, current.overlaid);
+                const replayedLayer = await replayed(record, confirmedLayer, current.queue);
+                const diff = await overlayDiff(record, current, replayedLayer.visible, replayedLayer.touched);
                 const answer = await local.commit({
                     rooms: [
                         {
@@ -3735,28 +3934,21 @@ export function composeRuntime(options) {
                         },
                     ],
                 });
-                const { count, indexed } = committedRoom(room.locator, answer);
-                replicas.set(room.locator, { ...held, record, overlaid: diff.touched, count, indexed });
+                preparedAfter(room.locator, answer);
                 changed = changeSet(room.locator, {
                     documents: answer.changed[room.locator] ?? [],
                     room: true,
                 });
             }
-            heldModel(room, next);
+            else
+                unheldModels.set(room.locator, next);
+            list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
             if (changed === null)
                 emitRooms();
             else
                 publishChangeSet(changed);
         });
     }
-    function heldModel(room, next) {
-        models.set(room.locator, next);
-        if (next.status === 'current') {
-            liveModels.set(room.locator, JSON.stringify(next.snapshot));
-            invalidModels.delete(room.locator);
-        }
-        list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
-    }
     async function scoped(result, room, local) {
         if (result.scope === 'content' && !result.retryable) {
             journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
@@ -3777,7 +3969,7 @@ export function composeRuntime(options) {
         else if (result.scope !== 'operation') {
             unreadable.add(room.locator);
             scopedAway = { ...room, replica: { ...room.replica, admission: 'unavailable' } };
-            await retainModel(local, scopedAway, modelOf(room.locator));
+            await retainModel(local, scopedAway, null);
         }
         if (!continuing())
             return;
@@ -3785,42 +3977,55 @@ export function composeRuntime(options) {
         emitRooms();
         journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
     }
-    function name(locator) {
+    async function name(locator) {
         const stream = options.adapter.roomStream;
-        const record = replicas.get(locator)?.record;
         const room = discovered.get(locator);
-        if (stream === undefined || record === undefined || room === undefined)
+        if (stream === undefined || room === undefined || !socketOpen || !handed)
             return;
-        if (!socketOpen || !handed || record.replica.selection !== room.replica.selection)
+        const [held] = await heldRooms([room]);
+        if (held === undefined || !socketOpen || !handed)
             return;
         naming += 1;
-        stream.hold([{ locator, roomVersion: record.roomVersion }]);
+        stream.hold([held]);
     }
-    function heldRooms(listed) {
+    async function heldRooms(listed) {
+        const stored = await storedRooms(listed.map((room) => room.locator));
         return listed.flatMap((room) => {
-            const record = replicas.get(room.locator)?.record;
-            if (record === undefined || record.replica.selection !== room.replica.selection)
+            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 prepared = await Promise.allSettled(listed.map((room) => prepareRoom(room, local, progress)));
+        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 held = await heldRooms(ready);
+        if (!live())
+            return;
         if (attempt === 'opened') {
             naming += 1;
-            options.adapter.roomStream?.hold(heldRooms(ready));
+            options.adapter.roomStream?.hold(held);
             handed = true;
         }
+        const kept = attempt === 'unstreamed'
+            ? new Set()
+            : new Set((await storedRooms(ready.map(({ locator }) => locator))).keys());
         for (const room of ready) {
-            if (attempt !== 'unstreamed' && replicas.has(room.locator)) {
+            if (attempt === 'opened' || kept.has(room.locator)) {
                 if (attempt === 'authorized')
-                    name(room.locator);
+                    await name(room.locator);
                 continue;
             }
             void roomTask(room.locator, (live) => loadRoom(room, local, progress, live)).then(() => rest(progress));
@@ -3829,23 +4034,23 @@ export function composeRuntime(options) {
         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)?.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;
         }
-        if (prior !== undefined)
-            await retainModel(local, room, modelOf(room.locator));
-        if (prior !== undefined)
+        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);
+        }
         if (discoveryPaused || authorization === undefined)
             return false;
         return room.replica.admission === 'admitted';
@@ -3853,26 +4058,28 @@ export function composeRuntime(options) {
     async function caughtUp(room, local, progress, live) {
         if (options.adapter.roomStream !== undefined || authorization === undefined)
             return;
-        if (!live() || !behind(room))
+        if (!live() || !(await behind(room)))
             return;
         const withheld = await advance(room, local, authorization, live);
         if (withheld !== null)
             await withhold(withheld, room, local, progress);
     }
-    function revoked(locator) {
-        const model = modelOf(locator);
-        return model.status === 'unavailable' && model.reason === 'revoked';
+    function revoked(model) {
+        return model?.status === 'unavailable' && model.reason === 'revoked';
     }
-    async function loadRoom(room, local, progress, live) {
+    async function loadRoom(room, local, progress, live, unheld) {
         if (!live() || authorization === undefined)
             return;
-        if (replicas.has(room.locator) && !(await prepareRoom(room, local, progress)))
-            return;
-        if (replicas.has(room.locator) && revoked(room.locator)) {
-            await reload(room, local, progress, live);
-            return;
+        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);
+        const withheld = await advance(room, local, authorization, live, unheld);
         if (withheld !== null) {
             await withhold(withheld, room, local, progress);
             return;
@@ -3885,8 +4092,9 @@ export function composeRuntime(options) {
                 reloadsDue.delete(room.locator);
             if (!live() || authorization === undefined)
                 return;
-            const from = standingOf(room.locator);
-            const bootstrapped = await pullBootstrap(authorization, room, local, live);
+            const prior = await recordAt(room.locator);
+            const from = standingAt(room.locator, prior);
+            const bootstrapped = await pullBootstrap(authorization, room, local, live, prior);
             if (bootstrapped.kind !== 'staged') {
                 if (live())
                     await withhold(bootstrapped, room, local, progress);
@@ -3910,7 +4118,7 @@ export function composeRuntime(options) {
     function malformed(listed) {
         for (const room of listed) {
             if (room.operations === undefined ||
-                !['write', 'delete'].every((operation) => Array.isArray(room.operations[operation]) &&
+                !['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' ||
@@ -3925,18 +4133,17 @@ export function composeRuntime(options) {
         return null;
     }
     async function signIn(local, signedIn) {
-        if (JSON.stringify(signedIn) === JSON.stringify(member))
+        if (JSON.stringify(signedIn) === JSON.stringify((await local.facts()).member))
             return;
         await local.fact('member', signedIn);
-        member = signedIn;
-        emitMember();
+        emitMember(signedIn);
     }
     async function discoverRooms(local, progress, attempt, live, found) {
         if (closed || authorization === undefined) {
             notifyReady();
             return;
         }
-        moveTo(transferring(status));
+        moveTo(transferring());
         discoveries += 1;
         const started = discoveries;
         const result = found ?? (await asked(authorization));
@@ -3981,15 +4188,13 @@ export function composeRuntime(options) {
             refusal = null;
             emitRefusal();
         }
-        const previousCapabilities = capabilities;
-        capabilities = result.capabilities;
-        notifyReady();
-        if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits) ||
-            JSON.stringify(result.capabilities) !== JSON.stringify(previousCapabilities)) {
-            limits = result.providerLimits;
-            await local.fact('providerLimits', limits);
-            await local.fact('capabilities', capabilities);
+        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);
     }
@@ -4072,7 +4277,7 @@ export function composeRuntime(options) {
                 streamed = progress;
             complete = false;
             recorded = false;
-            moveTo(transferring(status));
+            moveTo(transferring());
             try {
                 const local = await openLocal();
                 if (!live())
@@ -4107,7 +4312,7 @@ export function composeRuntime(options) {
             if (!live() || !announced)
                 return;
             const progress = { complete: true, reachable: true };
-            moveTo(transferring(status));
+            moveTo(transferring());
             try {
                 const local = await openLocal();
                 if (!live())
@@ -4132,7 +4337,7 @@ export function composeRuntime(options) {
                 return;
             countAuthorityChange();
             const progress = { complete: true, reachable: true };
-            moveTo(transferring(status));
+            moveTo(transferring());
             try {
                 const local = await openLocal();
                 if (!live())
@@ -4167,6 +4372,7 @@ export function composeRuntime(options) {
         missedChange ||= authorityChanged;
         handed = false;
         naming = 0;
+        unreadied();
         connectionLost();
         if (lost)
             conversations.lost();
@@ -4194,8 +4400,12 @@ export function composeRuntime(options) {
             await rest(null, live);
         });
     }
-    function cachedModels(local) {
-        return settleModels([...rooms.values()].map((room) => discovered.get(room.locator) ?? room), 'cached', local);
+    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;
@@ -4203,8 +4413,12 @@ export function composeRuntime(options) {
         naming = Math.max(0, naming - 1);
         const cycle = progress ?? { complete: true, reachable: true };
         replaced(expired);
-        const reloading = progress === null ? [] : owedReloads(expired);
-        const replacing = reloadNow((room) => expired.includes(room.locator) || reloading.includes(room.locator), cycle);
+        const installing = new Set(installs);
+        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;
@@ -4217,9 +4431,11 @@ export function composeRuntime(options) {
                 const local = await openLocal();
                 await replacing;
                 if (progress.reachable) {
-                    await settleModels([...discovered.values()].filter((room) => replicas.has(room.locator) &&
+                    const stored = await held;
+                    const owed = await reloading;
+                    await settleModels([...discovered.values()].filter((room) => stored.has(room.locator) &&
                         !expired.includes(room.locator) &&
-                        !reloading.includes(room.locator)), 'current', local);
+                        !owed.includes(room.locator)), 'current', local);
                 }
             }
             catch {
@@ -4230,24 +4446,34 @@ export function composeRuntime(options) {
                 await finishOpening(progress, live);
         });
     }
-    function owedReloads(expired) {
+    function owedReloads(expired, held) {
         const reloading = [...discovered.values()]
-            .filter((room) => replicas.has(room.locator) && !expired.includes(room.locator) && revoked(room.locator))
+            .filter((room) => !expired.includes(room.locator) && revoked(held.get(room.locator)?.record.model))
             .map((room) => room.locator);
         for (const locator of reloading)
             catching.add(locator);
-        liveQueries.recover();
+        recoverReads();
         return reloading;
     }
-    async function reloadNow(replaced, progress) {
-        const reloaded = [...discovered.values()].filter((room) => replicas.has(room.locator) && replaced(room));
+    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 {
             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 {
             for (const room of reloaded)
@@ -4256,29 +4482,56 @@ export function composeRuntime(options) {
         }
     }
     async function settleModels(held, status, local) {
-        const owed = (room) => {
-            const model = modelOf(room.locator);
-            return model.status !== 'unavailable' && model.status !== status;
-        };
-        const settled = await exclusive(async () => {
+        const owed = (model) => model.status !== 'unavailable' && model.status !== status;
+        const declaredAnew = await exclusive(async () => {
             if (!continuing())
                 return [];
-            const unchanged = held.filter((room) => owed(room) && declaredAsHeld(room));
+            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 next = { ...modelOf(room.locator), status };
-                const replica = replicas.get(room.locator);
-                if (replica !== undefined)
-                    replicas.set(room.locator, { ...replica, record: { ...replica.record, model: next } });
-                heldModel(room, next);
+                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 unchanged;
+            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 held) {
-            if (settled.includes(room) || !owed(room))
-                continue;
-            await retainModel(local, room, { ...modelOf(room.locator), status });
+        for (const room of declaredAnew) {
+            const model = await modelNow(room.locator);
+            if (owed(model))
+                await retainModel(local, room, { ...model, status });
         }
     }
     function submitLater(locator) {
@@ -4341,7 +4594,7 @@ export function composeRuntime(options) {
             return 'done';
         await rest(progress);
         if (!stale.has(locator)) {
-            if ((replicas.get(locator)?.queue.length ?? 0) > 0)
+            if ((await (await openLocal()).order(locator)).length > 0)
                 submitLater(locator);
             return 'done';
         }
@@ -4369,9 +4622,11 @@ export function composeRuntime(options) {
             return 'done';
         return reading.reachable && reading.complete ? 'done' : 'again';
     }
-    function submitAll() {
-        for (const [locator, replica] of replicas) {
-            if (replica.queue.length > 0)
+    async function submitAll() {
+        if (localSaves)
+            return;
+        for (const locator of await (await openLocal()).queued()) {
+            if (!isFenced(locator))
                 submitLater(locator);
         }
     }
@@ -4381,7 +4636,7 @@ export function composeRuntime(options) {
                 progress.complete = false;
                 return;
             }
-            submitAll();
+            await submitAll();
             for (const locator of stale)
                 if (repairable.has(locator))
                     repairLater(locator, {});
@@ -4410,8 +4665,14 @@ export function composeRuntime(options) {
     async function rest(progress, live = () => !closed) {
         if (!live())
             return;
-        let lastCompleted = status.lastCompleted;
-        let synced = complete && roomWork === 0 && naming === 0 && stale.size === 0 && !pending();
+        const settled = () => complete && roomWork === 0 && naming === 0 && 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 {
@@ -4419,21 +4680,15 @@ export function composeRuntime(options) {
                 if (!live())
                     return;
                 recorded = true;
-                lastCompleted = completedAt;
             }
             catch {
                 synced = false;
             }
         }
         moveTo({
-            state: pending()
-                ? 'pending'
-                : synced && complete && roomWork === 0 && naming === 0
-                    ? 'synced'
-                    : 'syncing',
-            lastCompleted,
+            state: synced && complete && roomWork === 0 && naming === 0 ? 'synced' : 'syncing',
             providerUnreachable: progress === null ? status.providerUnreachable : !progress.reachable,
-            ...attention(),
+            resting: true,
         });
     }
     function applyRoom(change) {
@@ -4449,22 +4704,26 @@ export function composeRuntime(options) {
                     if (!live())
                         return null;
                     const room = discovered.get(locator);
-                    const held = replicas.get(locator);
-                    if (room === undefined ||
-                        held === undefined ||
-                        room.replica.admission !== 'admitted' ||
-                        held.record.replica.selection !== room.replica.selection) {
+                    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;
                     }
-                    const at = held.record.roomVersion;
+                    if (held.replica.selection !== room.replica.selection)
+                        return null;
+                    const at = held.roomVersion;
                     if (options.adapter.reached(locator, at, change.roomVersion))
                         return progress;
-                    if (!options.adapter.reached(locator, at, change.from)) {
-                        name(locator);
+                    if (change.from === null || !options.adapter.reached(locator, at, change.from)) {
+                        await name(locator);
                         return progress;
                     }
                     if (underway === null)
-                        moveTo(transferring(status));
+                        moveTo(transferring());
                     const writing = () => live() && !full;
                     const refreshed = await ahead((hold) => pullRefresh(authorization ?? {}, held, writing, hold, () => change.read()));
                     if (refreshed.kind !== 'advanced')
@@ -4476,19 +4735,52 @@ export function composeRuntime(options) {
                     };
                     if (await publish(local, room, refreshed.record, landing, writing)) {
                         stale.delete(locator);
-                        await retainModel(local, room, modelOf(locator));
+                        if (!declaredAsHeld(held, room))
+                            await retainModel(local, room, null);
                         return progress;
                     }
                 }
             }
             catch {
                 if (!stale.has(locator))
-                    name(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(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(authorization, room, local, live, prior, carried);
+        if (bootstrapped.kind !== 'staged') {
+            if (live())
+                await withhold(bootstrapped, room, local, progress);
+            return;
+        }
+        await publish(local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
+    }
     function observeStream() {
         const stream = options.adapter.roomStream;
         if (stream === undefined || withdrawStream !== undefined)
@@ -4520,8 +4812,11 @@ export function composeRuntime(options) {
                 closedSocket(event.revoked, event.lost, event.authorityChanged);
             else if (event.kind === 'caught-up')
                 void caughtUpRooms(event.expired);
-            else if (event.kind === 'authority-changed')
+            else if (event.kind === 'authority-changed') {
+                if (announced && socketOpen)
+                    fenceLive(event.left);
                 void changeAuthority(event);
+            }
             else
                 void applyRoom(event);
         });
@@ -4554,10 +4849,7 @@ export function composeRuntime(options) {
         withdrawConversations = stream.observe((event) => {
             if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted')
                 queueReadiness();
-            if (conversations.receive(event)) {
-                void ready.then(scheduleCurrency);
-                return;
-            }
+            conversations.receive(event);
             if (event.kind !== 'gap' || conversations.current())
                 return;
             show();
@@ -4581,7 +4873,7 @@ export function composeRuntime(options) {
             return;
         }
         const progress = { complete: false, reachable: !status.providerUnreachable };
-        moveTo(transferring(status));
+        moveTo(transferring());
         try {
             await conversations.catchUp(progress);
         }
@@ -4595,6 +4887,7 @@ export function composeRuntime(options) {
             return;
         closed = true;
         notifyDiscovered();
+        unreadied();
         if (probing !== null)
             clearInterval(probing);
         connectionLive();
@@ -4616,12 +4909,14 @@ export function composeRuntime(options) {
         memberListeners.clear();
         authorityChangeListeners.clear();
         liveQueries.close();
+        figures.close();
         queueSubscriptions.clear();
         roomDraftListeners.clear();
         presentationListeners.clear();
     }
     async function stop() {
         stopping = true;
+        unreadied();
         inFlight.abort();
         await recovery.retire();
         await Promise.all(working);
@@ -4634,16 +4929,18 @@ export function composeRuntime(options) {
     if (options.signal?.aborted)
         close();
     observeStream();
-    void openLocal().then(() => {
-        if (capabilities.length > 0)
+    void openLocal()
+        .then(async (local) => {
+        if ((await local.facts()).capabilities.length > 0)
             readyFromStore();
-    }, () => {
+    })
+        .catch(() => {
         readyFromStore();
     });
     if (options.adapter.roomStream === undefined)
         void sync('unstreamed', null);
-    function planned(input, reach) {
-        const plan = planWithin(input, roomFacts(reach), planReach(reach));
+    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;
@@ -4662,10 +4959,10 @@ export function composeRuntime(options) {
         const watchers = seedWatchers.get(plan.key) ?? new Set();
         seedWatchers.set(plan.key, watchers);
         watchers.add(shown);
-        const stop = liveQueries.watch(plan, identityOf(plan), () => {
-            const cover = covered(plan);
+        const stop = liveQueries.watch(plan, identityOf(plan), (held) => {
+            const cover = covered(plan, held);
             awaitPreparation(cover);
-            return seedBehind(plan, cover);
+            return seedBehind(plan, cover, held);
         }, (message) => {
             const answered = message;
             pending = whole(answered) && 'pending' in answered.result;
@@ -4683,6 +4980,21 @@ export function composeRuntime(options) {
             stop();
         };
     }
+    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;
@@ -4695,7 +5007,7 @@ export function composeRuntime(options) {
                 retryable: false,
             };
         }
-        if (closed || refusal !== null || connectionOf() !== 'connected')
+        if (closed || refusal !== null || (await connectionNow()) !== 'connected')
             return OFFLINE;
         const reached = reach === null ? null : new Set(reach.rooms);
         const named = asked.rooms === null
@@ -4703,7 +5015,8 @@ export function composeRuntime(options) {
                 ? null
                 : [...reached]
             : asked.rooms.filter((room) => reached === null || reached.has(room));
-        const rooms = named === null ? null : named.filter((room) => replicas.has(room)).sort();
+        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 {
@@ -4741,18 +5054,15 @@ export function composeRuntime(options) {
             roomDraftListeners.add(listener);
             void exclusive(async () => {
                 await openLocal();
-            }).then(() => {
+            }).then(() => publication(async () => {
                 if (closed || !roomDraftListeners.has(listener))
                     return;
-                const snapshot = snapshotRoomDrafts();
-                draftsShown = draftsShown.then(async () => {
-                    const value = await snapshot.catch(() => null);
-                    if (value === null || closed || !roomDraftListeners.has(listener))
-                        return;
-                    listener.ready = true;
-                    listener.notify(value);
-                });
-            }, () => { });
+                const value = await snapshotRoomDrafts();
+                if (closed || !roomDraftListeners.has(listener))
+                    return;
+                listener.ready = true;
+                listener.notify(value);
+            }), () => { });
             return () => {
                 roomDraftListeners.delete(listener);
             };
@@ -4764,6 +5074,8 @@ export function composeRuntime(options) {
             return conversations.watchList(deliver);
         if (topic === 'agents')
             return conversations.watchAgents(deliver);
+        if (topic === 'figures')
+            return figures.watch(deliver, fail);
         if (topic === 'presentation') {
             const listener = {
                 app: input[0],
@@ -4772,13 +5084,12 @@ export function composeRuntime(options) {
             };
             presentationListeners.add(listener);
             void exclusive(async () => {
-                await openLocal();
-            }).then(() => {
+                const value = await presentationOf(listener.app);
                 if (closed || !presentationListeners.has(listener))
                     return;
                 listener.ready = true;
-                listener.notify(presentationOf(listener.app));
-            }, () => { });
+                listener.notify(value);
+            }).catch(() => { });
             return () => {
                 presentationListeners.delete(listener);
             };
@@ -4792,6 +5103,8 @@ export function composeRuntime(options) {
             return () => {
                 unlistedRooms.delete(deliver);
                 roomListeners.delete(deliver);
+                if (roomListeners.size === 0)
+                    roomsShown = null;
             };
         }
         if (topic === 'connection-refusal') {
@@ -4824,7 +5137,12 @@ export function composeRuntime(options) {
         }
         if (topic === 'member') {
             memberListeners.add(deliver);
-            deliver(member);
+            void openLocal()
+                .then((local) => local.facts())
+                .then(({ member }) => {
+                if (memberListeners.has(deliver))
+                    deliver(member);
+            }, () => { });
             return () => {
                 memberListeners.delete(deliver);
             };
@@ -4839,12 +5157,18 @@ export function composeRuntime(options) {
         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);
             };
         }
-        return watchPlan(planned(input[0], null), deliver, fail);
+        return watchPlanned(planned(input[0], null), deliver, fail);
     };
     const md = {
         loaded() {
@@ -4863,15 +5187,14 @@ export function composeRuntime(options) {
                 emitKnownRooms();
             });
         },
-        query: ((input) => rowsQuery(planned(input, null))),
+        query: ((input) => planned(input, null).then(rowsQuery)),
         search: (input) => searched(input, null),
-        types(locator) {
+        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(builtIn),
+                collection: modelTypes(isFenced(locator) ? NO_MODEL : modelIn(locator, held)),
+                typedSelection: (room?.typedSelection ?? null) === null ? null : modelTypes(builtIn),
             };
         },
         roomDraft: {
@@ -4885,7 +5208,7 @@ export function composeRuntime(options) {
                 });
             },
             async read(room, path) {
-                const record = roomDrafts.get(room)?.get(path);
+                const record = await draftOf(room, path);
                 return record === undefined ? null : ((await roomDraftsOf([record]))[0] ?? null);
             },
             write(room, path, revision, input, next = roomDraftRevision()) {
@@ -4903,14 +5226,15 @@ export function composeRuntime(options) {
             discard(room, path, revision) {
                 return exclusive(async () => {
                     const local = await openLocal();
-                    const current = roomDrafts.get(room)?.get(path);
+                    const current = await draftOf(room, path);
                     if (current === undefined || current.revision !== revision) {
                         return staleWrite(current === undefined ? null : ((await roomDraftsOf([current]))[0] ?? null));
                     }
                     await local.discardRoomDraft(room, path);
-                    forgetRoomDraft(room, path);
-                    publishChangeSet(changeSet(room, { drafts: [path] }));
-                    moveTo({ ...status, ...attention() });
+                    await Promise.all([
+                        publishChangeSet(changeSet(room, { drafts: [path] })),
+                        moveTo(status),
+                    ]);
                     return { outcome: 'written', roomDraft: null };
                 });
             },
@@ -4919,10 +5243,7 @@ export function composeRuntime(options) {
         chatDraft: conversations.chatDraft,
         presentation: {
             read(app) {
-                return exclusive(async () => {
-                    await openLocal();
-                    return presentationOf(app);
-                });
+                return exclusive(() => presentationOf(app));
             },
             write(app, value) {
                 return exclusive(() => keptPresentation(app, () => structuredClone(value)));
@@ -4955,7 +5276,8 @@ export function composeRuntime(options) {
         },
         async call(name, input) {
             await ready;
-            const room = calledRooms(name, input).find((one) => locked(one));
+            const lockedNow = await lockedRooms();
+            const room = (await calledRooms(name, input)).find((one) => lockedNow.includes(one));
             return room === undefined ? recoveredAction(name, input) : lockedRoom(room);
         },
         async reached(locator, roomVersion, path) {
@@ -5008,7 +5330,7 @@ export function composeRuntime(options) {
         lockedRooms,
         watchLocks,
         located,
-        room: (locator) => listed().find((one) => one.locator === locator),
+        room: async (locator) => shownRooms(await listingNow()).find((one) => one.locator === locator),
     };
     return {
         md,