@agentshouse/mdruntime 0.1.0-c5d3fa6fb67bc → 0.1.0-c6636685d0c4b

package/dist/connection.js

@@ -1,36 +1,47 @@
 import { attachedModel } from './attached-model.js';
 import { cached, modelTypes, NO_MODEL, sameModel, } from './model.js';
-import { observing } from './observation.js';
-import { filterOf, identityOf, planOf, } from './query.js';
+import { observing, whole } from './observation.js';
+import { filterOf, identityOf, planOf, plain, queryKey, } from './query.js';
 import { createReadSide } from './read-side.js';
+import { seededResult } from './seed.js';
 import { markdownPath, roomOfKey } from './rows.js';
 import { createSearchIndex, searchPlanOf, } from './search.js';
+import { capped, MAXIMUM_WINDOW } from './windows.js';
 import { bootstrapRoom } from './bootstrap.js';
-import { changeSet, entering, mergeChangeSets } from './change-set.js';
+import { changeSet, changing, entering, mergeChangeSets } from './change-set.js';
 import { createConversationStore, } from './conversation.js';
 import { queuedFile } from './change.js';
 import { indexReferrers, referencesIndexed, validRoot, } from './collection.js';
 import { runtimeError } from './failure.js';
 import { createLog } from './log.js';
 import { binaryRecord } from './binary.js';
-import { absentBinary, binaryAnswer, calledResult, failure, historyAnswer, undeclared, UNCERTAIN, } from './outcome.js';
+import { absentBinary, binaryAnswer, binaryLinkAnswer, calledResult, failure, historyAnswer, lockedRoom, undeclared, UNCERTAIN, } from './outcome.js';
 import { createRecovery } from './recovery.js';
+import { doorReads } from './reads.js';
 import { refreshRoom } from './refresh.js';
-import { buildBatch, joined, limitedIn, requeued } from './save.js';
-import { applyReturned, compositionOf, confirmedOf, landed, readReclassified, replicaOf, sameMembership, withdrawals, } from './replica.js';
-import { binaryBase, changedParts, changesOf, held, heldFile, joinedDraft, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
+import { buildBatch, joined, limitedIn, queuedDocuments, requeued, } from './save.js';
+import { applyReturned, compositionOf, confirmedOf, landed, readReclassified, replicaOf, replicating, sameMembership, standing, } from './replica.js';
+import { binaryBase, changedParts, changesOf, held, heldFile, joinedDraft, moveTarget, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
 import { same, saving, STARTING, transferring, } from './status.js';
 import { detectStorageLoss, nextGeneration } from './durability.js';
-import { demanded, narrower, WHOLE_DEMAND, wider } from './acquisition.js';
 import { readinessOf, SETTLED_ROOMS, } from './readiness.js';
 import { FencedMap } from './fence.js';
 import { tally } from './shared.js';
-import { inChunks, ROW_WEIGHT, yielded } from './turn.js';
+import { inChunks, ROW_WEIGHT, stepped, yielded } from './turn.js';
 import { identityTime, roomDraftRevision } from './identity.js';
 import { beneath, normalize } from './paths.js';
 import { openRuntimeStore, } from './store.js';
 import { unconfirmed } from './transfer.js';
 import { governs, holds, narrowed, planReach, } from './reach.js';
+function roomsAlone(plan) {
+    return (plan.reach === null &&
+        plan.root.types === null &&
+        plan.root.where === null &&
+        plan.root.pathPrefix === null &&
+        plan.paths === null &&
+        plan.hop === null &&
+        plan.backlinks === null);
+}
 function within(root, path) {
     return root === '' || beneath(root, path);
 }
@@ -48,6 +59,12 @@ const OPENING_LANE = 'opening';
 const CONVERSATION_LANE = 'conversations';
 const ROOM_READS = 256;
 const ROOM_ATTEMPTS = 16;
+// A Room that locks offline stays readable this long after the connection drops, so a laptop waking or changing network keeps working while a disconnected device locks soon after.
+const LOCK_GRACE_MS = 120_000;
+function operationOf(input) {
+    const operation = input?.operation_id;
+    return typeof operation === 'string' ? operation : null;
+}
 const outside = new Map();
 function outsideOf(roots) {
     const key = JSON.stringify(roots);
@@ -87,6 +104,8 @@ export function composeRuntime(options) {
     const replicas = new FencedMap(isFenced);
     const queuesWithoutReplica = new FencedMap(isFenced);
     const pendings = new Map();
+    const seeds = new Map();
+    const seedWatchers = new Map();
     const roomDrafts = new FencedMap(isFenced);
     const presentations = new Map();
     let limits = [];
@@ -99,6 +118,7 @@ export function composeRuntime(options) {
     const liveModels = new FencedMap(isModelFenced);
     const invalidModels = new Set();
     const discovered = new Map();
+    const reads = doorReads(options.adapter, (locator) => discovered.get(locator), () => generation);
     let roomsListed = false;
     const scopedRefusals = new Map();
     const sourceRefusals = new Map();
@@ -135,6 +155,7 @@ export function composeRuntime(options) {
     let handed = false;
     const recovery = (options.recovery ?? createRecovery()).scope(ROOM_ATTEMPTS);
     const repairing = new Set();
+    const calling = new Set();
     const repairable = new Map();
     let outcomeRetention = null;
     const answering = new Map();
@@ -145,6 +166,7 @@ export function composeRuntime(options) {
     let discovering = null;
     let opened = null;
     const owed = new Set();
+    const reloadsDue = new Map();
     const lanes = new Map();
     let roomReads = { generation, free: ROOM_READS, waiting: [] };
     const working = new Set();
@@ -160,6 +182,9 @@ export function composeRuntime(options) {
     let withdrawConversations;
     let currencyQueued = null;
     let socketOpen = false;
+    const confirmed = new Set();
+    let lockGrace = null;
+    const lockListeners = new Set();
     let serviceMode = 'open';
     let haltedRefusal = false;
     let openSignals = 0;
@@ -171,8 +196,6 @@ export function composeRuntime(options) {
     const unpreparedDemand = new Set();
     const unindexable = new Set();
     let preparing = false;
-    let demand = WHOLE_DEMAND;
-    let narrowing = null;
     let targets = {};
     let persistence = options.shell.persistence;
     let capacity = null;
@@ -189,7 +212,7 @@ export function composeRuntime(options) {
         durably,
         stream: () => options.adapter.conversations,
         publish: publishChangeSet,
-        online: () => !status.providerUnreachable && refusal === null,
+        online: () => connectionOf() !== 'unreachable' && refusal === null,
         closed: () => closed,
         unanswered: resendLater,
         expired: (operation) => pastHorizon(operation),
@@ -255,6 +278,15 @@ export function composeRuntime(options) {
         const value = presentations.get(app);
         return value === undefined ? null : structuredClone(value);
     }
+    function keepPresentation(app, next) {
+        return exclusive(async () => {
+            const local = await openLocal();
+            const stored = next(presentations.get(app));
+            await local.present({ app, value: stored });
+            presentations.set(app, stored);
+            publishChangeSet(changeSet('', null, null, { presentation: app }));
+        });
+    }
     function emitPresentation(app) {
         if (closed)
             return;
@@ -315,9 +347,63 @@ export function composeRuntime(options) {
         return structuredClone([...rooms.values()].map((room) => {
             const documents = documentsIn(room.locator);
             counted.set(room.locator, documents);
-            return { ...room, documents };
+            return locked(room.locator)
+                ? {
+                    ...room,
+                    model: modelTypes(NO_MODEL),
+                    typedSelection: null,
+                    documents: 0,
+                    locked: true,
+                }
+                : { ...room, documents, locked: false };
         }));
     }
+    function locked(locator) {
+        return rooms.get(locator)?.replica.offline === 'locked' && !confirmed.has(locator);
+    }
+    function lockedRooms() {
+        return [...rooms.keys()].filter(locked).sort();
+    }
+    function relocked(before) {
+        const after = lockedRooms();
+        if (JSON.stringify(after) === JSON.stringify(before))
+            return;
+        journal.record(`locked ${after.length}`);
+        emitRooms();
+        for (const notify of [...lockListeners])
+            notify();
+    }
+    function confirmLocks(listed) {
+        if (!socketOpen)
+            return;
+        for (const room of listed) {
+            if (room.replica.admission === 'admitted')
+                confirmed.add(room.locator);
+        }
+    }
+    function connectionLost() {
+        if (lockGrace !== null || closed)
+            return;
+        lockGrace = setTimeout(() => {
+            lockGrace = null;
+            if (socketOpen || closed)
+                return;
+            const before = lockedRooms();
+            confirmed.clear();
+            relocked(before);
+        }, LOCK_GRACE_MS);
+    }
+    function connectionLive() {
+        if (lockGrace !== null)
+            clearTimeout(lockGrace);
+        lockGrace = null;
+    }
+    function watchLocks(notify) {
+        lockListeners.add(notify);
+        return () => {
+            lockListeners.delete(notify);
+        };
+    }
     function roomFacts(reach = null) {
         const held = [...rooms.values()]
             .filter((room) => holds(reach, room.locator))
@@ -366,7 +452,7 @@ export function composeRuntime(options) {
         if (closed)
             return;
         queueReadiness();
-        const next = status.state === 'synced' && demand.conversations && !conversations.current()
+        const next = status.state === 'synced' && !conversations.current()
             ? { ...status, state: 'syncing' }
             : status;
         if (same(shown, next))
@@ -399,8 +485,12 @@ export function composeRuntime(options) {
             ...set,
             documents: set.documents.filter(({ locator }) => prepared.has(locator) || projecting.has(locator)),
         };
-        readSide.apply(held);
-        searchIndex.changed(held);
+        const applied = readSide.apply(held, () => searchIndex.changed(held));
+        if (applied instanceof Promise)
+            void applied.catch(unpublished);
+    }
+    function unpublished(error) {
+        journal.record(`publication failed ${error instanceof Error ? error.name : 'unknown'}`);
     }
     async function referenced(locator) {
         for (;;) {
@@ -431,8 +521,8 @@ export function composeRuntime(options) {
                 if (current === undefined || closed)
                     return;
                 const set = entering(locator, current, chunk);
-                readSide.apply(set);
                 entered.push(set);
+                return readSide.apply(set);
             });
             if (!replicas.has(locator) || closed)
                 return;
@@ -474,17 +564,22 @@ export function composeRuntime(options) {
             }
         })();
     }
+    function roomsOfReach(reach) {
+        return new Set([...reach.rooms, ...reach.documents.map(roomOfKey)]);
+    }
     function reachedRooms(plan) {
-        const reach = plan.reach;
-        const reached = reach === null ? null : new Set([...reach.rooms, ...reach.documents.map(roomOfKey)]);
+        const reached = plan.reach === null ? null : roomsOfReach(plan.reach);
         const named = plan.rooms ??
             (reached === null
                 ? [...new Set([...rooms.keys(), ...replicas.keys(), ...queuesWithoutReplica.keys()])]
                 : [...reached]);
-        return [...new Set(named)].filter((locator) => reached === null || reached.has(locator)).sort();
+        return [...new Set(named)]
+            .filter((locator) => (reached === null || reached.has(locator)) && !plan.locked.includes(locator))
+            .sort();
     }
     function awaited(locator) {
-        return rooms.has(locator) || !roomsListed;
+        return (!roomsListed ||
+            (rooms.has(locator) && discovered.get(locator)?.replica.admission === 'admitted'));
     }
     function covered(plan) {
         const locators = reachedRooms(plan);
@@ -524,61 +619,11 @@ export function composeRuntime(options) {
         if (waiting.length > 0)
             prepare(waiting.map(({ room }) => room));
     }
-    function acquires(room) {
-        return (demanded(demand, room) ||
-            (replicas.get(room.locator)?.queue.length ?? 0) > 0 ||
-            queuesWithoutReplica.has(room.locator));
-    }
-    function acquiredLocators() {
-        return [...discovered.values()]
-            .filter(acquires)
-            .map((room) => room.locator)
-            .sort();
-    }
-    function heldDemand(acquired) {
-        if (demand.whole)
-            return null;
-        return { rooms: acquired.map((room) => room.locator), conversations: demand.conversations };
-    }
-    function applyDemand(next) {
-        const before = acquiredLocators();
-        const conversed = demand.conversations;
-        demand = next;
-        const after = acquiredLocators();
-        queueReadiness();
-        if (!conversed && next.conversations)
-            scheduleCurrency();
-        if (JSON.stringify(before) === JSON.stringify(after) && conversed === next.conversations)
-            return;
-        journal.record(`acquisition ${next.whole ? 'whole' : after.length}`);
-        if (options.adapter.roomStream === undefined)
-            void sync('unstreamed');
-        else if (socketOpen)
-            options.adapter.roomStream.reopen();
-    }
-    function acquire(next) {
-        if (closed)
-            return;
-        if (narrowing !== null)
-            clearTimeout(narrowing);
-        narrowing = null;
-        const widening = wider(next, demand);
-        if (!widening && !narrower(next, demand))
-            return;
-        if (widening || !roomsListed) {
-            applyDemand(next);
-            return;
-        }
-        // A narrower demand waits five seconds, so a tab that reloads returns before the stream reopens twice.
-        narrowing = setTimeout(() => {
-            narrowing = null;
-            applyDemand(next);
-        }, 5_000);
-    }
-    function requiredRooms(reach) {
+    function requiredRooms(given) {
+        const reach = planReach(given);
         if (reach === null)
             return { listed: roomsListed, rooms: [...rooms.keys()].sort() };
-        const named = [...new Set(reach.rooms)].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 };
@@ -772,10 +817,7 @@ export function composeRuntime(options) {
             void sync('unstreamed');
     }
     async function reclaimed(local) {
-        const unreferenced = [...transfers.keys()].filter((locator) => {
-            const room = discovered.get(locator);
-            return room === undefined || !acquires(room);
-        });
+        const unreferenced = [...transfers.keys()].filter((locator) => !discovered.has(locator));
         for (const locator of unreferenced) {
             await local.abandon(locator);
             transfers.delete(locator);
@@ -801,18 +843,54 @@ export function composeRuntime(options) {
         const available = await estimated().catch(() => null);
         pause(locator, { cause: 'quota-exceeded', needed: bytes, available });
     }
+    function seedRoomHeld(room, version) {
+        return prepared.has(room) && reachedBy(room, version);
+    }
+    function seedHeld(at) {
+        return Object.entries(at).every(([room, version]) => (roomsListed && !rooms.has(room)) || seedRoomHeld(room, version));
+    }
+    function seedApplies(plan) {
+        const seed = seeds.get(plan.key);
+        if (seed === undefined)
+            return null;
+        if (!seedHeld(seed.at))
+            return seed;
+        seeds.delete(plan.key);
+        return null;
+    }
+    function seedBehind(plan, cover) {
+        const seed = seedApplies(plan);
+        if (seed === null || 'pending' in cover)
+            return cover;
+        return {
+            pending: Object.entries(seed.at)
+                .filter(([room, version]) => !seedRoomHeld(room, version))
+                .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();
+        }
+    }
     async function rowsQuery(plan) {
         const before = covered(plan);
         awaitPreparation(before);
+        const seeded = seedApplies(plan);
+        if (seeded !== null)
+            return seededResult(seeded).result;
         if ('pending' in before)
             return before;
         const { rows, at: cover } = await readSide.query(plan, () => covered(plan));
         awaitPreparation(cover);
         if ('pending' in cover)
             return cover;
-        return 'groups' in rows
-            ? { groups: rows.groups, coverage: cover.coverage }
-            : { documents: rows.documents, coverage: cover.coverage };
+        return { ...rows, coverage: cover.coverage };
     }
     async function indexConversation(conversation) {
         searchIndex.indexMessages(conversation, [], false);
@@ -956,20 +1034,28 @@ export function composeRuntime(options) {
             refusal: scopedRefusals.get(room.locator) ?? sourceRefusals.get(room.locator) ?? null,
         });
     }
-    async function applyDiscovery(found, started) {
+    async function applyDiscovery(found, started, covered) {
+        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);
         }
+        await loseRooms(found
+            .filter((room) => room.replica.admission !== 'admitted' && heldLocally(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)
             scopedRefusals.delete(locator);
-        discovered.clear();
+        if (covered === undefined)
+            discovered.clear();
+        else
+            for (const locator of covered)
+                discovered.delete(locator);
         for (const room of listed)
             discovered.set(room.locator, room);
-        const unlisted = unlistedHeld(new Set(found.map((room) => room.locator)));
+        const unlisted = unlistedHeld(new Set(found.map((room) => room.locator))).filter((locator) => covered === undefined || covered.includes(locator));
         if (options.adapter.exhaustiveDiscovery === true)
             await loseRooms(unlisted);
         else
@@ -982,10 +1068,18 @@ export function composeRuntime(options) {
             }
             list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
         }
+        confirmLocks(listed);
         roomsListed = true;
         emitRooms();
+        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([
@@ -1015,6 +1109,7 @@ export function composeRuntime(options) {
         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(batch.id);
             replicas.delete(locator);
@@ -1221,8 +1316,9 @@ export function composeRuntime(options) {
     }
     async function settle(local, locator, before, confirmed, queue, settling = {}) {
         const previousQueue = before?.queue ?? queuesWithoutReplica.get(locator) ?? [];
-        const withdrawn = withdrawals(confirmed, queue, withdrawable, localSaves);
-        const kept = queue.filter((batch) => !withdrawn.includes(batch));
+        const { withdrawn, kept } = await stepped(standing(confirmed, queue, withdrawable, localSaves));
+        const founded = kept.filter((batch) => !queue.includes(batch));
+        const queueChanged = kept.length !== previousQueue.length || founded.length > 0;
         const unqueued = withdrawn.map((batch) => ({
             batch,
             returned: localSaves || landed(batch, confirmed) ? null : returnedBy('withdrawn'),
@@ -1246,9 +1342,10 @@ export function composeRuntime(options) {
                 });
             }
         }
-        await local.keepAuthored({ locator, queue: kept, roomDrafts: [...written.values()] });
+        await local.keepAuthored({ locator, queue: kept, founded, roomDrafts: [...written.values()] });
+        const staying = new Set(kept.map((batch) => batch.id));
         for (const batch of previousQueue) {
-            if (!kept.includes(batch))
+            if (!staying.has(batch.id))
                 pendings.delete(batch.id);
         }
         for (const record of written.values())
@@ -1261,34 +1358,38 @@ export function composeRuntime(options) {
             });
         }
         catch (error) {
-            const held = before === undefined ? null : replicaOf(before.confirmed, kept, before);
+            const held = before === undefined ? null : await stepped(replicating(before.confirmed, kept, before));
+            const set = await stepped(changing(locator, before ?? null, held, {
+                queue: queueChanged,
+                drafts: [...written.keys()],
+            }));
             if (held !== null)
                 replicas.set(locator, held);
             else if (kept.length > 0)
                 queuesWithoutReplica.set(locator, kept);
             else
                 queuesWithoutReplica.delete(locator);
-            publishChangeSet(changeSet(locator, before ?? null, held, {
-                queue: kept.length !== previousQueue.length,
-                drafts: [...written.keys()],
-            }));
+            publishChangeSet(set);
             moveTo({ ...status, ...attention() });
             throw error;
         }
+        const changed = { room: settling.room, queue: queueChanged, drafts: [...written.keys()] };
+        const next = await stepped(replicating(confirmed, kept, before));
+        const set = await stepped(changing(locator, before ?? null, next, changed));
         return () => {
             queuesWithoutReplica.delete(locator);
             for (const { batch, returned } of unqueued) {
                 const outcome = localSaves ? 'dropped' : returned === null ? 'landed' : 'withdrawn';
                 journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
             }
-            replicas.set(locator, replicaOf(confirmed, kept, before));
-            return changeSet(locator, before ?? null, replicas.get(locator) ?? null, {
-                room: settling.room,
-                queue: kept.length !== previousQueue.length,
-                drafts: [...written.keys()],
-            });
+            replicas.set(locator, next);
+            return heldChange(locator, before ?? null, next, set, changed);
         };
     }
+    function heldChange(locator, before, next, set, changed) {
+        const held = replicas.get(locator) ?? null;
+        return held === next ? set : changeSet(locator, before, held, changed);
+    }
     function adoptModels(locator, record) {
         for (const [attached, model] of [
             ['collection', record.model],
@@ -1376,7 +1477,7 @@ export function composeRuntime(options) {
             return true;
         });
     }
-    async function saveRoomDrafts(locator, named, writtenBy) {
+    async function savedRoom(locator) {
         const local = await openLocal();
         await referenced(locator);
         const replica = replicas.get(locator);
@@ -1384,6 +1485,10 @@ export function composeRuntime(options) {
         if (replica === undefined || room === undefined) {
             throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
         }
+        return { local, replica, room };
+    }
+    async function saveRoomDrafts(locator, named, writtenBy) {
+        const target = await savedRoom(locator);
         const saved = [];
         for (const { path, revision } of named) {
             const record = roomDrafts.get(locator)?.get(path);
@@ -1393,6 +1498,38 @@ export function composeRuntime(options) {
             if (!saved.some((draft) => draft.path === path))
                 saved.push({ path, parts: record.parts });
         }
+        return committed(locator, target, saved, new Set(saved.map(({ path }) => path)), writtenBy);
+    }
+    async function saveParts(locator, named, writtenBy) {
+        const read = named.map(({ path, parts }) => ({ path, parts: readParts(parts) }));
+        if (read.some(({ path }, at) => path === '' ||
+            normalize(path) !== path ||
+            read.findIndex((one) => one.path === path) !== at)) {
+            throw runtimeError('room-draft-malformed');
+        }
+        const target = await savedRoom(locator);
+        const saved = [];
+        for (const { path, parts } of read) {
+            const file = parts.file === undefined
+                ? undefined
+                : await heldFile(parts.file.blob, binaryBase(target.replica.visible, path));
+            saved.push({ path, parts: held(undefined, parts, file) });
+        }
+        return committed(locator, target, saved, new Set(), writtenBy);
+    }
+    function carriedDrafts(locator, saved, consumed) {
+        const holding = roomDrafts.get(locator);
+        return new Map(saved.flatMap(({ path, parts }) => {
+            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)
+                return [];
+            return [[path, { ...record, path: to, revision: roomDraftRevision() }]];
+        }));
+    }
+    async function committed(locator, { local, replica, room }, saved, consumed, writtenBy) {
         const changed = saved.flatMap(({ path, parts }) => changedParts(path, underneath(parts, path, replica.visible)));
         if (changed.length > 0)
             return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
@@ -1425,6 +1562,7 @@ export function composeRuntime(options) {
             visible: replica.visible,
             changes,
             bases: parts.flatMap(({ bases }) => bases),
+            queued: queuedDocuments(replica.queue),
             writtenBy,
             clean: {
                 text: replica.confirmed.record.documents,
@@ -1432,7 +1570,9 @@ export function composeRuntime(options) {
                 composition: compositionOf(replica.confirmed.record),
             },
         };
-        const checked = withdrawing ? buildBatch({ ...input, queued: requeue.queued }) : null;
+        const checked = withdrawing
+            ? await buildBatch({ ...input, queued: new Set([...input.queued, ...requeue.queued]) })
+            : null;
         if (checked?.kind === 'refused')
             return { outcome: 'refused', ...checked.refusal };
         const owners = [...requeue.owners].flatMap((origin) => {
@@ -1448,13 +1588,15 @@ export function composeRuntime(options) {
             };
         }
         const built = !withdrawing
-            ? buildBatch(input)
+            ? await buildBatch(input)
             : requeue.changes.length === 0
                 ? null
-                : buildBatch({
+                : await buildBatch({
                     ...input,
-                    visible: replicaOf(replica.confirmed, requeue.queue, replica).visible,
+                    visible: (await stepped(replicating(replica.confirmed, requeue.queue, replica)))
+                        .visible,
                     changes: requeue.changes,
+                    queued: queuedDocuments(requeue.queue),
                 });
         if (built?.kind === 'refused')
             return { outcome: 'refused', ...built.refusal };
@@ -1489,18 +1631,26 @@ export function composeRuntime(options) {
             if (limited !== null)
                 return { outcome: 'refused', ...limited };
         }
-        const consumed = saved.map(({ path }) => path);
+        const carried = carriedDrafts(locator, saved, consumed);
+        const left = [...consumed, ...carried.keys()];
+        const arrived = [...carried.values()];
         try {
             await local.keepAuthored({
                 locator,
                 queue: batches,
                 saved: drafted,
-                consumedRoomDrafts: consumed,
+                consumedRoomDrafts: left,
+                roomDrafts: arrived,
             });
         }
         catch {
             return { outcome: 'refused', code: 'durable-write', retryable: true };
         }
+        const next = await stepped(replicating(replica.confirmed, batches, replica));
+        const set = await stepped(changing(locator, replica, next, {
+            queue: true,
+            drafts: [...left, ...arrived.map(({ path }) => path)],
+        }));
         if (fences.has(locator))
             throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
         for (const origin of withdrawn.keys())
@@ -1510,13 +1660,12 @@ export function composeRuntime(options) {
         }
         if (!localSaves)
             recorded = false;
-        for (const path of consumed)
+        for (const path of left)
             forgetRoomDraft(locator, path);
-        replicas.set(locator, replicaOf(replica.confirmed, batches, replica));
-        publishChangeSet(changeSet(locator, replica, replicas.get(locator) ?? null, {
-            queue: true,
-            drafts: consumed,
-        }));
+        for (const record of arrived)
+            rememberRoomDraft(record);
+        replicas.set(locator, next);
+        publishChangeSet(set);
         moveTo({ ...(localSaves ? status : saving(status)), ...attention() });
         submitLater(locator);
         const identifier = join?.batch.id ??
@@ -1606,7 +1755,7 @@ export function composeRuntime(options) {
         const scope = options.adapter.referrerScope(request.referrer);
         return scope?.kind === 'room' ? scope.locator : null;
     }
-    async function readBinary(request) {
+    async function transferBinary(request, transfer, answer) {
         if (closed || refusal !== null)
             return UNCERTAIN;
         try {
@@ -1622,40 +1771,41 @@ export function composeRuntime(options) {
             ? `transfer binary ${request.locator} ${request.path}`
             : `transfer binary ${request.fileRef}`);
         try {
-            const result = await options.adapter.binary(authorization, request);
-            journal.record(`outcome binary ${result.kind}`);
+            const result = await transfer(authorization);
+            const settled = result;
+            journal.record(`outcome binary ${settled.kind}`);
             const locator = binaryRoom(request);
             if (locator !== null && fencedSince(locator, since))
                 return failure({ kind: 'room-not-readable', locator });
-            if (result.kind === 'scoped-refusal') {
-                const room = replicas.get(result.locator)?.confirmed.record;
+            if (settled.kind === 'scoped-refusal') {
+                const room = replicas.get(settled.locator)?.confirmed.record;
                 if (room !== undefined)
-                    await scoped(result, room, await openLocal());
+                    await scoped(settled, room, await openLocal());
             }
-            if (result.kind === 'revoked-authorization')
+            if (settled.kind === 'revoked-authorization')
                 await refuse('revoked-authorization');
-            return binaryAnswer(result);
+            return answer(result);
         }
         catch {
             journal.record('outcome binary transport-uncertainty');
             return UNCERTAIN;
         }
     }
-    async function readBinaryPath(locator, path, revision) {
-        await ready;
+    function readBinary(request) {
+        return transferBinary(request, (held) => options.adapter.binary(held, request), binaryAnswer);
+    }
+    function binaryPath(locator, path, revision) {
         if (revision !== undefined)
-            return readBinary({ kind: 'path', locator, path, revision });
+            return { kind: 'path', locator, path, revision };
         const visible = replicas.get(locator)?.visible;
         const held = visible?.binaries[path];
         if (visible === undefined || held === undefined)
-            return absentBinary(path);
-        if (held.state === 'pending') {
-            const blob = queuedBlob(locator, path, held.localId);
-            return blob === null ? absentBinary(path) : { kind: 'binary', blob };
-        }
+            return null;
+        if (held.state === 'pending')
+            return { kind: 'pending', localId: held.localId };
         const record = binaryRecord(path, held, visible.revisions[path]);
         if (record.state !== 'accepted')
-            return absentBinary(path);
+            return null;
         const replica = replicas.get(locator);
         const queued = (replica?.queue ?? []).flatMap((batch) => batch.changes);
         const holds = (at) => {
@@ -1670,13 +1820,31 @@ export function composeRuntime(options) {
             if (change.kind === 'move' && change.to === confirmed)
                 confirmed = change.path;
         }
-        return readBinary({
+        return {
             kind: 'path',
             locator,
             path: confirmed,
             revision: record.revision,
             fileRef: record.fileRef,
-        });
+        };
+    }
+    async function readBinaryPath(locator, path, revision) {
+        await ready;
+        const asked = binaryPath(locator, path, revision);
+        if (asked === null)
+            return absentBinary(path);
+        if (asked.kind === 'pending') {
+            const blob = queuedBlob(locator, path, asked.localId);
+            return blob === null ? absentBinary(path) : { kind: 'binary', blob };
+        }
+        return readBinary(asked);
+    }
+    async function linkBinaryPath(locator, path, revision) {
+        await ready;
+        const asked = binaryPath(locator, path, revision);
+        if (asked === null || asked.kind === 'pending')
+            return absentBinary(path);
+        return transferBinary(asked, (held) => options.adapter.link(held, asked), binaryLinkAnswer);
     }
     async function readBinaryReference(reference) {
         await ready;
@@ -1702,7 +1870,14 @@ export function composeRuntime(options) {
         }
         return undefined;
     }
-    async function invokeAction(name, input) {
+    function calledRoom(name, input) {
+        const member = declaredAction(name)?.room;
+        if (member === undefined || input === null || typeof input !== 'object')
+            return null;
+        const room = input[member];
+        return typeof room === 'string' ? room : null;
+    }
+    async function invokeAction(name, input, dispatching) {
         await ready;
         if (closed || refusal !== null)
             return UNCERTAIN;
@@ -1716,6 +1891,7 @@ export function composeRuntime(options) {
         }
         if (closed || authorization === undefined || refusal !== null)
             return UNCERTAIN;
+        await dispatching?.();
         journal.record(`transfer action ${name}`);
         try {
             const result = await options.adapter.action(authorization, { name, input });
@@ -1736,6 +1912,60 @@ export function composeRuntime(options) {
             return UNCERTAIN;
         }
     }
+    function unsettled(result) {
+        return result.kind !== 'action' && result.retryable;
+    }
+    async function recoveredAction(name, input) {
+        const operation = operationOf(input);
+        if (operation === null)
+            return invokeAction(name, input);
+        const kept = async () => (await openLocal()).keepCall({ operation, name, input });
+        calling.add(operation);
+        try {
+            let result = await invokeAction(name, input, kept);
+            if (unsettled(result)) {
+                await recovery.attempt(`action ${operation}`, async () => {
+                    if (closed || refusal !== null)
+                        return 'done';
+                    if (!socketOpen)
+                        return 'again';
+                    result = await invokeAction(name, input, kept);
+                    return unsettled(result) ? 'again' : 'done';
+                }, { again: true });
+            }
+            if (!unsettled(result))
+                await (await openLocal()).dropCall(operation);
+            return result;
+        }
+        finally {
+            calling.delete(operation);
+        }
+    }
+    async function resendCalls(signal) {
+        if (!socketOpen || closed || stopping)
+            return 'done';
+        const local = await openLocal();
+        for (const held of await local.calls()) {
+            if (calling.has(held.operation))
+                continue;
+            if (closed || signal.aborted)
+                return 'done';
+            if (pastHorizon(held.operation)) {
+                await local.dropCall(held.operation);
+                continue;
+            }
+            calling.add(held.operation);
+            try {
+                if (unsettled(await invokeAction(held.name, held.input)))
+                    return 'again';
+                await local.dropCall(held.operation);
+            }
+            finally {
+                calling.delete(held.operation);
+            }
+        }
+        return 'done';
+    }
     function continuing() {
         return !closed && !discoveryPaused;
     }
@@ -1753,8 +1983,9 @@ export function composeRuntime(options) {
     async function pullRefresh(authorized, confirmed, live) {
         if (!live())
             return unconfirmed;
+        const turn = generation;
         try {
-            const result = await refreshRoom(options.adapter, authorized, confirmed, (models, held) => (live() ? remodel(confirmed.record.locator, models, held) : held), live);
+            const result = await refreshRoom(reads, authorized, confirmed, (models, held) => (live() ? remodel(confirmed.record.locator, models, held) : held), live);
             const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
             return result;
@@ -1763,6 +1994,9 @@ export function composeRuntime(options) {
             journal.record(`transfer refresh ${confirmed.record.locator} transport-uncertainty`);
             throw error;
         }
+        finally {
+            reads.finished(confirmed.record.locator, turn);
+        }
     }
     function staging(local, live) {
         return {
@@ -1805,12 +2039,13 @@ export function composeRuntime(options) {
     async function pullBootstrap(authorized, room, local, live) {
         if (!live())
             return unconfirmed;
+        const turn = generation;
         if (replicas.has(room.locator)) {
             catching.add(room.locator);
             readSide.recover();
         }
         try {
-            const result = await bootstrapRoom(options.adapter, authorized, room, {
+            const result = await bootstrapRoom(reads, authorized, room, {
                 collection: modelOf(room.locator),
                 selection: modelOf(room.locator, 'typed-selection'),
             }, (models, held) => (live() ? remodel(room.locator, models, held) : held), live, staging(local, live), reusable(room));
@@ -1825,12 +2060,28 @@ export function composeRuntime(options) {
             caughtUpTo(room.locator);
             throw error;
         }
+        finally {
+            reads.finished(room.locator, turn);
+        }
     }
     function caughtUpTo(locator) {
         if (catching.delete(locator))
             readSide.recover();
     }
+    function behind(room) {
+        const held = replicas.get(room.locator)?.confirmed.record.roomVersion;
+        return (held !== undefined &&
+            [announced.get(room.locator), room.roomVersion].some((later) => later !== undefined && !options.adapter.reached(room.locator, held, later)));
+    }
     async function advance(room, local, authorized, live) {
+        const carried = reads.carried(room.locator);
+        const withheld = await advanceOnce(room, local, authorized, live);
+        if (withheld !== null || reads.carried(room.locator) === carried || !behind(room)) {
+            return withheld;
+        }
+        return advanceOnce(room, local, authorized, live);
+    }
+    async function advanceOnce(room, local, authorized, live) {
         await referenced(room.locator);
         if (!live() || paused.has(room.locator))
             return unconfirmed;
@@ -1867,6 +2118,8 @@ export function composeRuntime(options) {
                 readSide.recover();
                 return unconfirmed;
             }
+            if (reloadsDue.get(room.locator) === generation)
+                return unconfirmed;
         }
         const bootstrapped = await pullBootstrap(authorized, room, local, live);
         if (!live())
@@ -1958,7 +2211,7 @@ export function composeRuntime(options) {
         logAccepted(room.locator, submitted, accepted);
         const applied = options.adapter.reached(room.locator, held, accepted.roomVersion)
             ? { kind: 'staged', confirmed: current.confirmed }
-            : applyReturned(current.confirmed, submitted, accepted, options.adapter.follows(room.locator, held, accepted.roomVersion)
+            : await applyReturned(current.confirmed, submitted, accepted, options.adapter.follows(room.locator, held, accepted.roomVersion)
                 ? accepted.roomVersion
                 : held, accepted.roomVersion);
         if (applied.kind !== 'staged') {
@@ -2220,6 +2473,7 @@ export function composeRuntime(options) {
             if (!continuing())
                 return;
             const held = replicas.get(room.locator);
+            let changed = null;
             if (held !== undefined) {
                 const declared = {
                     ...held.confirmed.record,
@@ -2230,7 +2484,7 @@ export function composeRuntime(options) {
                 };
                 const reclassified = sameMembership(declared, held.confirmed.record)
                     ? { kind: 'staged', confirmed: confirmedOf(declared, held.confirmed) }
-                    : readReclassified(declared, held.confirmed);
+                    : await readReclassified(declared, held.confirmed);
                 const record = reclassified.kind === 'staged'
                     ? declared
                     : {
@@ -2241,15 +2495,19 @@ export function composeRuntime(options) {
                     ? { kind: 'staged', confirmed: confirmedOf(record, held.confirmed) }
                     : reclassified;
                 await local.write({ next: record, previous: held.confirmed.record });
+                const replica = read.kind === 'staged'
+                    ? await stepped(replicating(read.confirmed, held.queue, held))
+                    : { ...held, confirmed: { ...held.confirmed, record } };
+                const set = await stepped(changing(room.locator, held, replica, { room: true }));
+                replicas.set(room.locator, replica);
+                changed = heldChange(room.locator, held, replica, set, { room: true });
                 if (read.kind === 'staged') {
-                    replicas.set(room.locator, replicaOf(read.confirmed, held.queue, held));
                     if (declarationRefusals.delete(room.locator)) {
                         sourceRefusals.delete(room.locator);
                         unreadable.delete(room.locator);
                     }
                 }
-                else if (read.kind === 'refused') {
-                    replicas.set(room.locator, { ...held, confirmed: { ...held.confirmed, record } });
+                else {
                     refusedSource(room, read);
                     declarationRefusals.add(room.locator);
                 }
@@ -2260,13 +2518,18 @@ export function composeRuntime(options) {
                 invalidModels.delete(key);
             }
             list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
-            if (held === undefined)
+            if (changed === null)
                 emitRooms();
             else
-                publishChangeSet(changeSet(room.locator, held, replicas.get(room.locator) ?? null, { room: true }));
+                publishChangeSet(changed);
         });
     }
     async function scoped(result, room, local) {
+        if (result.scope === 'content' && !result.retryable) {
+            journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
+            await loseRooms([room.locator]);
+            return;
+        }
         scopedRefusals.set(room.locator, {
             code: result.code,
             fields: result.fields,
@@ -2280,15 +2543,7 @@ export function composeRuntime(options) {
             });
         else if (result.scope !== 'operation') {
             unreadable.add(room.locator);
-            scopedAway = {
-                ...room,
-                replica: { ...room.replica, admission: 'unavailable' },
-                operations: {
-                    ...room.operations,
-                    ...(result.scope === 'content' ? { read: [] } : {}),
-                    ...(result.scope === 'sync' ? { sync: [] } : {}),
-                },
-            };
+            scopedAway = { ...room, replica: { ...room.replica, admission: 'unavailable' } };
             await retainModel(local, scopedAway, 'collection', modelOf(room.locator));
         }
         if (!continuing())
@@ -2313,16 +2568,15 @@ export function composeRuntime(options) {
         });
     }
     async function synchronize(listed, local, progress, attempt, live) {
-        const acquired = listed.filter(acquires);
-        const prepared = await Promise.allSettled(acquired.map((room) => prepareRoom(room, local, progress)));
+        const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(room, local, progress)));
         if (!live())
             return;
-        const ready = acquired.filter((_, index) => {
+        const ready = listed.filter((_, index) => {
             const outcome = prepared[index];
             return outcome?.status === 'fulfilled' && outcome.value;
         });
         if (attempt === 'opened') {
-            options.adapter.roomStream?.hold(heldRooms(ready), heldDemand(acquired));
+            options.adapter.roomStream?.hold(heldRooms(ready));
             handed = true;
         }
         discovering?.release();
@@ -2350,19 +2604,10 @@ export function composeRuntime(options) {
             await retainModel(local, room, 'collection', modelOf(room.locator));
         if (discoveryPaused || authorization === undefined)
             return false;
-        if (room.replica.admission !== 'admitted') {
-            if (replicas.has(room.locator))
-                progress.complete = false;
-            return false;
-        }
-        return true;
+        return room.replica.admission === 'admitted';
     }
     async function caughtUp(room, local, progress, live) {
-        const held = replicas.get(room.locator)?.confirmed.record.roomVersion;
-        if (held === undefined || authorization === undefined || !live())
-            return;
-        const behind = [announced.get(room.locator), room.roomVersion].some((later) => later !== undefined && !options.adapter.reached(room.locator, held, later));
-        if (!behind)
+        if (authorization === undefined || !live() || !behind(room))
             return;
         const withheld = await advance(room, local, authorization, live);
         if (withheld !== null)
@@ -2390,6 +2635,8 @@ export function composeRuntime(options) {
     }
     async function reload(room, local, progress, live) {
         try {
+            if (live())
+                reloadsDue.delete(room.locator);
             if (!live() || authorization === undefined)
                 return;
             const bootstrapped = await pullBootstrap(authorization, room, local, live);
@@ -2406,7 +2653,7 @@ export function composeRuntime(options) {
             caughtUpTo(room.locator);
         }
     }
-    async function discoverRooms(local, progress, attempt, live) {
+    async function discoverRooms(local, progress, attempt, live, scope) {
         if (closed || authorization === undefined) {
             notifyReady();
             return;
@@ -2416,7 +2663,7 @@ export function composeRuntime(options) {
         const started = discoveries;
         let result;
         try {
-            result = await options.adapter.discover(authorization);
+            result = await options.adapter.discover(authorization, scope);
         }
         catch {
             result = { kind: 'transport-uncertainty' };
@@ -2456,12 +2703,13 @@ export function composeRuntime(options) {
         }
         for (const room of result.rooms) {
             if (room.operations === undefined ||
-                !['read', 'sync', 'write', 'delete'].every((operation) => Array.isArray(room.operations[operation]) &&
+                !['write', 'delete'].every((operation) => Array.isArray(room.operations[operation]) &&
                     room.operations[operation].every((scope) => typeof scope === 'string')) ||
                 room.replica === undefined ||
                 typeof room.replica.selection !== 'string' ||
                 room.replica.selection.length === 0 ||
-                !['admitted', 'unavailable'].includes(room.replica.admission)) {
+                !['admitted', 'unavailable'].includes(room.replica.admission) ||
+                !['locked', 'open'].includes(room.replica.offline)) {
                 journal.record(`invalid model or replica declaration ${room.locator}`);
                 await refuse('missing-required-guarantee');
                 notifyReady();
@@ -2493,7 +2741,7 @@ export function composeRuntime(options) {
             member = signedIn;
             emitMember();
         }
-        await synchronize(await applyDiscovery(result.rooms, started), local, progress, attempt, live);
+        await synchronize(await applyDiscovery(result.rooms, started, result.covered), local, progress, attempt, live);
     }
     async function ensureAuthorization() {
         if (authorization !== undefined)
@@ -2590,9 +2838,44 @@ export function composeRuntime(options) {
             options.adapter.roomStream?.reopen();
         });
     }
-    function closedSocket(revoked) {
+    function rediscover(scope) {
+        return task(OPENING_LANE, async (live) => {
+            if (!live() || !socketOpen)
+                return;
+            const progress = { complete: true, reachable: true };
+            const gate = discover();
+            moveTo(transferring(status));
+            try {
+                const local = await openLocal();
+                if (!live())
+                    return;
+                await ensureAuthorization();
+                if (!live())
+                    return;
+                await discoverRooms(local, progress, 'authorized', live, scope);
+            }
+            catch {
+                progress.complete = false;
+            }
+            finally {
+                gate.release();
+                notifyReady();
+            }
+            if (!live())
+                return;
+            if (!progress.complete)
+                complete = false;
+            await rest(progress, live);
+        });
+    }
+    function closedSocket(revoked, lost) {
         const opened = socketOpen;
         socketOpen = false;
+        connectionLost();
+        if (lost) {
+            reads.lost();
+            conversations.lost();
+        }
         if (revoked) {
             void refuse('revoked-authorization');
             return;
@@ -2609,9 +2892,10 @@ export function composeRuntime(options) {
     function applyOpening(expired) {
         const progress = underway?.generation === generation ? underway.progress : null;
         const cycle = progress ?? { complete: true, reachable: true };
-        const replacing = reloadNow((room) => expired.includes(room.locator), cycle);
         if (opened === generation)
             opened = null;
+        const reloading = progress === null ? [] : owedReloads(expired);
+        const replacing = reloadNow((room) => expired.includes(room.locator) || reloading.includes(room.locator), cycle);
         return task(OPENING_LANE, async (live) => {
             underway = null;
             if (!live())
@@ -2621,24 +2905,17 @@ export function composeRuntime(options) {
                 await rest(cycle, live);
                 return;
             }
-            await roomsCarried(expired);
+            await roomsCarried([...expired, ...reloading]);
             if (!live())
                 return;
-            const replaced = new Set(owed);
-            owed.clear();
             try {
                 const local = await openLocal();
-                const held = [...discovered.values()].filter((room) => replicas.has(room.locator));
-                const reloading = held.filter((room) => !expired.includes(room.locator) &&
-                    (replaced.has(room.locator) || revoked(room.locator)));
-                for (const room of reloading)
-                    catching.add(room.locator);
-                readSide.recover();
-                const reloads = Promise.allSettled(reloading.map((room) => roomTask(room.locator, (current) => reload(room, local, progress, current))));
-                const reloaded = [...(await reloads), ...(await replacing)];
+                const reloaded = await replacing;
                 if (progress.reachable) {
-                    for (const room of held) {
-                        if (!expired.includes(room.locator) && !reloading.includes(room)) {
+                    for (const room of discovered.values()) {
+                        if (replicas.has(room.locator) &&
+                            !expired.includes(room.locator) &&
+                            !reloading.includes(room.locator)) {
                             await confirmModels(room, local);
                         }
                     }
@@ -2655,14 +2932,29 @@ export function composeRuntime(options) {
                 await finishOpening(progress, live);
         });
     }
+    function owedReloads(expired) {
+        const reloading = [...discovered.values()]
+            .filter((room) => replicas.has(room.locator) &&
+            !expired.includes(room.locator) &&
+            (owed.has(room.locator) || revoked(room.locator)))
+            .map((room) => room.locator);
+        owed.clear();
+        for (const locator of reloading)
+            catching.add(locator);
+        readSide.recover();
+        return reloading;
+    }
     async function reloadNow(replaced, progress) {
+        const reloaded = [...discovered.values()].filter((room) => replicas.has(room.locator) && replaced(room));
+        for (const room of reloaded)
+            reloadsDue.set(room.locator, generation);
         try {
             const local = await openLocal();
-            return await Promise.allSettled([...discovered.values()]
-                .filter((room) => replicas.has(room.locator) && replaced(room))
-                .map((room) => roomTask(room.locator, (live) => reload(room, local, progress, live))));
+            return await Promise.allSettled(reloaded.map((room) => roomTask(room.locator, (live) => reload(room, local, progress, live))));
         }
         catch {
+            for (const room of reloaded)
+                reloadsDue.delete(room.locator);
             progress.reachable = false;
             return [];
         }
@@ -2779,6 +3071,7 @@ export function composeRuntime(options) {
                 progress.complete = false;
                 return;
             }
+            reads.applied();
             submitAll();
             for (const locator of stale)
                 if (repairable.has(locator))
@@ -2787,10 +3080,11 @@ export function composeRuntime(options) {
             if (status.providerUnreachable)
                 conversations.reconnected();
             const reading = { complete: true, reachable: true };
-            if (demand.conversations)
-                await conversations.catchUp(reading);
+            await conversations.catchUp(reading);
             if (progress.reachable && reading.reachable)
                 await conversations.resend(reading);
+            if (progress.reachable)
+                void recovery.attempt('calls', resendCalls);
             if (!reading.reachable) {
                 progress.reachable = false;
                 resendLater();
@@ -2851,7 +3145,7 @@ export function composeRuntime(options) {
                 return;
             const room = discovered.get(locator);
             const held = replicas.get(locator);
-            if (room === undefined || room.replica.admission !== 'admitted' || !acquires(room))
+            if (room === undefined || room.replica.admission !== 'admitted')
                 return;
             if (held !== undefined &&
                 (held.confirmed.record.replica.selection !== room.replica.selection ||
@@ -2902,15 +3196,19 @@ export function composeRuntime(options) {
                 return;
             if (event.kind === 'opened') {
                 socketOpen = true;
+                connectionLive();
                 generation += 1;
+                reads.opened();
                 conversations.reopened();
                 recovery.resume();
                 void sync('opened');
             }
             else if (event.kind === 'closed')
-                closedSocket(event.revoked);
+                closedSocket(event.revoked, event.lost);
             else if (event.kind === 'opening')
                 void applyOpening(event.expired);
+            else if (event.kind === 'authority-changed')
+                void rediscover(event.scope);
             else
                 void applyRoom(event.locator, event.roomVersion);
         }, receipts);
@@ -2965,7 +3263,7 @@ export function composeRuntime(options) {
         if (!live())
             return;
         await conversations.reconcile();
-        if (conversations.current() || !demand.conversations) {
+        if (conversations.current()) {
             show();
             return;
         }
@@ -2983,10 +3281,10 @@ export function composeRuntime(options) {
         if (closed)
             return;
         closed = true;
-        if (narrowing !== null)
-            clearTimeout(narrowing);
         if (rechecking !== null)
             clearInterval(rechecking);
+        connectionLive();
+        lockListeners.clear();
         readinessWatches.clear();
         withdrawStream?.();
         withdrawStream = undefined;
@@ -3032,22 +3330,63 @@ export function composeRuntime(options) {
     if (options.adapter.roomStream === undefined)
         void sync('unstreamed');
     function planned(input, reach) {
-        return planOf(input, roomFacts(reach), planReach(reach));
+        const plan = planOf(input, roomFacts(reach), planReach(reach));
+        const named = plan.paths !== null &&
+            plan.rooms !== null &&
+            plan.paths.length * plan.rooms.length <= MAXIMUM_WINDOW;
+        return plan.limit === null && named ? plan : { ...plan, limit: capped(plan.limit) };
     }
     function watchPlan(plan, deliver) {
-        return readSide.watch(plan, identityOf(plan), () => {
+        let seeded = false;
+        let pending = true;
+        const shown = () => {
+            const seed = seeds.get(plan.key);
+            if (seed === undefined || seeded || !pending)
+                return;
+            seeded = true;
+            deliver(seededResult(seed));
+        };
+        const watchers = seedWatchers.get(plan.key) ?? new Set();
+        seedWatchers.set(plan.key, watchers);
+        watchers.add(shown);
+        const stop = readSide.watch(plan, identityOf(plan), () => {
             const cover = covered(plan);
             awaitPreparation(cover);
-            return cover;
-        }, deliver);
+            return seedBehind(plan, cover);
+        }, (message) => {
+            const answered = message;
+            pending = whole(answered) && 'pending' in answered.result;
+            if (pending && seeds.has(plan.key)) {
+                shown();
+                return;
+            }
+            seeded = false;
+            deliver(message);
+        });
+        return () => {
+            watchers.delete(shown);
+            if (watchers.size === 0)
+                seedWatchers.delete(plan.key);
+            stop();
+        };
     }
-    async function searched(input, reach) {
-        const plan = searchPlanOf(input);
-        const filter = filterOf(plan.documents ?? {}, roomFacts(reach), planReach(reach));
+    async function searched(input, reach, locked) {
+        const asked = searchPlanOf(input);
+        const plan = { ...asked, limit: capped(asked.limit) };
+        const filter = {
+            ...filterOf(plan.documents ?? {}, roomFacts(reach), planReach(reach)),
+            locked,
+        };
+        const unlocking = (filter.rooms ?? [])
+            .filter((room) => locked.includes(room))
+            .map((room) => ({ room, awaits: 'unlock' }));
         for (;;) {
             const cover = covered(filter);
             awaitPreparation(cover);
-            const pending = 'pending' in cover ? [...cover.pending] : [];
+            const pending = [
+                ...unlocking,
+                ...('pending' in cover ? cover.pending : []),
+            ];
             const awaited = new Set('pending' in cover ? cover.pending.map(({ room }) => room) : []);
             const held = covered({
                 ...filter,
@@ -3081,22 +3420,34 @@ export function composeRuntime(options) {
             if ('pending' in answered)
                 continue;
             const searchedConversations = named.filter((one) => searchIndex.conversations().has(one));
+            await readSide.settled();
             const seen = searchIndex.changes();
             await searchIndex.caughtUp();
-            const selected = plan.documents === undefined && reach === null ? null : await rowsQuery(answering);
+            const selected = roomsAlone(answering) ? null : await rowsQuery(answering);
             if (selected !== null && 'pending' in selected)
                 continue;
             if (searchIndex.changes() !== seen ||
                 JSON.stringify(covered(answering)) !== JSON.stringify(answered))
                 continue;
-            const hits = searchIndex.search(plan, selected === null ? null : selected.documents, searchedConversations, complete ? null : new Set(answering.rooms));
+            const hits = searchIndex.search(plan, selected === null ? null : selected.documents, searchedConversations, answering.rooms !== null
+                ? new Set(answering.rooms)
+                : locked.length === 0
+                    ? null
+                    : new Set(reachedRooms(answering)), plan.collection
+                ? new Map(answered.coverage.rooms.map(({ room }) => [
+                    room,
+                    replicas.get(room)?.confirmed.record.typedSelection?.roots ?? [],
+                ]))
+                : null);
             const coverage = {
                 rooms: answered.coverage.rooms,
                 conversations: searchedConversations,
                 index: searchIndex.generation(),
                 overlay: answered.coverage.overlay,
             };
-            return complete ? { ...hits, coverage } : { pending, ...hits, coverage };
+            return complete
+                ? { ...hits, coverage }
+                : { pending, documents: hits.documents, messages: hits.messages, coverage };
         }
     }
     const watch = (topic, input, deliver) => {
@@ -3206,7 +3557,7 @@ export function composeRuntime(options) {
             return listed();
         },
         query: ((input) => rowsQuery(planned(input, null))),
-        search: (input) => searched(input, null),
+        search: (input) => searched(input, null, []),
         types(locator) {
             return {
                 collection: modelTypes(modelOf(locator)),
@@ -3281,27 +3632,33 @@ export function composeRuntime(options) {
                 });
             },
             write(app, value) {
-                return exclusive(async () => {
-                    const local = await openLocal();
-                    const stored = structuredClone(value);
-                    await local.present({ app, value: stored });
-                    presentations.set(app, stored);
-                    publishChangeSet(changeSet('', null, null, { presentation: app }));
-                });
+                return keepPresentation(app, () => structuredClone(value));
+            },
+            edit(app, members) {
+                return keepPresentation(app, (held) => Object.fromEntries([
+                    ...Object.entries(plain(held) ? held : {}).filter(([member]) => !Object.hasOwn(members, member)),
+                    ...Object.entries(structuredClone(members)).filter(([, value]) => value !== null),
+                ]));
             },
         },
         save(room, named, writtenBy) {
             return exclusive(() => saveRoomDrafts(room, named, writtenBy));
         },
+        saveParts(room, parts, writtenBy) {
+            return exclusive(() => saveParts(room, parts, writtenBy));
+        },
         history(locator, path, query) {
             return readHistory(locator, path, query);
         },
         binaryFile: {
             read: readBinaryPath,
+            link: linkBinaryPath,
             readReference: readBinaryReference,
         },
-        call(name, input) {
-            return invokeAction(name, input);
+        async call(name, input) {
+            await ready;
+            const room = calledRoom(name, input);
+            return room !== null && locked(room) ? lockedRoom(room) : recoveredAction(name, input);
         },
         reached(locator, roomVersion, path) {
             return path === undefined
@@ -3346,13 +3703,16 @@ export function composeRuntime(options) {
         watchPlan,
         search: searched,
         watchReadiness,
+        locked,
+        lockedRooms,
+        watchLocks,
     };
     return {
         md,
+        seed,
         stop,
         lose: loseRooms,
         watch,
-        acquire,
         persisted(answer) {
             if (answer === persistence)
                 return;