@agentshouse/mdruntime 0.1.0-cee9c8aa4cd86 → 0.1.0-cf1e7fdb9c600

package/dist/connection.js

@@ -1,8 +1,8 @@
-import { escapePointer, parseFrontmatter, roomTarget, target } from '@agentshouse/mdmodel';
-import { attachedModel, NO_ROOM_TYPES, roomTypesOf } from './attached-model.js';
+import { bodied, identityOf, parseFrontmatter, plain, queryKey, roomTarget, target, } from '@agentshouse/mdmodel';
+import { attachedModel, builtInModel, roomTypesOf } from './attached-model.js';
 import { cached, modelTypes, NO_MODEL, sameModel, } from './model.js';
 import { observing, whole } from './observation.js';
-import { filterOf, identityOf, planOf, plain, queryKey, } from './query.js';
+import { planWithin, } from './query.js';
 import { createLiveQueries } from './live.js';
 import { seededResult } from './seed.js';
 import { documentKey, roomOfKey } from './rows.js';
@@ -12,29 +12,28 @@ import { bootstrapRoom } from './bootstrap.js';
 import { changeSet, mergeChangeSets } from './change-set.js';
 import { createConversationStore, } from './conversation.js';
 import { leaving as leavingIn, partnerOf, queuedFile, } from './change.js';
-import { available, collectionOf, unreadable as unreadableIn, validRoot, } from './collection.js';
+import { available, collectionOf, composedOf, validRoot, } from './collection.js';
 import { runtimeError } from './failure.js';
 import { createLog } from './log.js';
 import { binaryRecord } from './binary.js';
+import { attachedFile } from './file.js';
 import { openedFiles } from './opened.js';
-import { ABSENT_TARGET, absentBinary, absentReference, binaryAnswer, binaryLinkAnswer, calledResult, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, undeclared, UNCERTAIN, UNREADABLE, } from './outcome.js';
+import { ABSENT_TARGET, absentBinary, attachAnswer, binaryAnswer, binaryLinkAnswer, calledResult, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, OFFLINE, undeclared, UNCERTAIN, UNREADABLE, } from './outcome.js';
 import { createRecovery } from './recovery.js';
-import { doorReads } from './reads.js';
 import { advancement } from './refresh.js';
 import { buildBatch, buildMove, joined, limiting, queuedDocuments, requeuing, } from './save.js';
-import { compositionOf, entryAt, landed, movedBy, overlayOf, replaying, returning, returnedPaths, sameMembership, slicing, slicingWith, standing, storedRecord, touchedBy, } from './replica.js';
-import { binaryBase, changedParts, changesOf, held, heldFile, joinedDraft, moveTarget, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.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 { detectStorageLoss, nextGeneration } from './durability.js';
-import { readinessOf, SETTLED_ROOMS, } from './readiness.js';
+import { detectStorageLoss, nextGeneration, refusedForSpace, } from './durability.js';
+import { readinessOf, } from './readiness.js';
 import { FencedMap } from './fence.js';
-import { fingerprint } from './stored.js';
 import { sameBinary } from './overlay.js';
 import { paced, ROW_WEIGHT, stepped, yielded } from './turn.js';
 import { identityTime, roomDraftRevision } from './identity.js';
-import { beneath, normalize } from './paths.js';
+import { ancestors, beneath, normalize } from './paths.js';
 import { openRuntimeStore, } from './store.js';
-import { changedCleanly, sameComposition, validatedCollection, } from './validation.js';
+import { validatedNeighbourhood } from './validation.js';
 import { unconfirmed } from './transfer.js';
 import { governs, holds, narrowed, planReach, } from './reach.js';
 function within(root, path) {
@@ -55,34 +54,44 @@ const CONVERSATION_LANE = 'conversations';
 const ROOM_READS = 256;
 const ROOM_ATTEMPTS = 16;
 const ERASE_BATCH = 512;
-const REDERIVE_BATCH = 256;
-const WALK_BYTES = 1 << 20;
+const DERIVE_BYTES = 1 << 23;
+const DERIVE_FLOOR = 1 << 18;
+// An index build aims at this much database work, so a Save, a query or the next part's progress waits behind at most one short build.
+const DERIVE_AIM_MS = 250;
+// A build past its floor of text stops after a second and a half of work, its full-text writes included, so a Room whose text costs ten times the usual holds a Save, a query or the next part's progress behind no longer build.
+const DERIVE_LONGEST_MS = 1_500;
 const QUERY_BYTES = 1 << 20;
 const STAGE_BYTES = 1 << 20;
-const CLEAN_CHANGES = 2_000;
+const STAGE_FLOOR = 1 << 16;
+// A batch aims at this much database work, so a Save or a query waits behind at most one short write.
+const STAGE_AIM_MS = 50;
+const STREAMS_HELD = 4;
+const NOTHING_HELD = { bytes: 0 };
+const QUEUED_TEXT = 1 << 23;
+// 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.
 const LOCK_GRACE_MS = 120_000;
 function operationOf(input) {
     const operation = input?.operation_id;
     return typeof operation === 'string' ? operation : null;
 }
-function abandonedOn(signal) {
-    return new Promise((resolve) => {
-        if (signal.aborted)
-            resolve(null);
-        else
-            signal.addEventListener('abort', () => resolve(null), { once: true });
+function readUntil(read, signal) {
+    if (signal.aborted)
+        return Promise.resolve({ kind: 'transport-uncertainty' });
+    return new Promise((resolve, reject) => {
+        const stop = () => resolve({ kind: 'transport-uncertainty' });
+        signal.addEventListener('abort', stop, { once: true });
+        read.then(resolve, reject).finally(() => signal.removeEventListener('abort', stop));
     });
 }
-function roomLane(locator) {
-    return `room ${locator}`;
-}
+const TEXT_READS = 4;
 function pendingKey(locator, id) {
     return `${locator}\u0000${id}`;
 }
 export function composeRuntime(options) {
     const localSaves = options.adapter.localSaves === true;
-    const roomTypes = roomTypesOf(options.adapter.roomTypes);
+    const roomTypes = roomTypesOf(options.adapter.roomTypes, options.adapter.nameableRoomTypes);
     let authorization = options.authorization;
     let opening;
     const fences = new Map();
@@ -92,44 +101,53 @@ export function composeRuntime(options) {
     const fencedSince = (locator, since) => fences.has(locator) || (lastFenced.get(locator) ?? 0) > since;
     let discoveries = 0;
     const replicas = new FencedMap(isFenced);
+    const reopened = new Set();
+    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 unreadable = new Set();
-    const isModelFenced = (key) => isFenced(key.slice(key.indexOf(' ') + 1));
-    const models = new FencedMap(isModelFenced);
-    const liveModels = new FencedMap(isModelFenced);
+    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();
-    const reads = doorReads(options.adapter, (locator) => discovered.get(locator), () => generation);
+    let inFlight = new AbortController();
+    const refreshed = options.adapter.refresh?.bind(options.adapter);
+    const reads = {
+        bootstrap: (authorized, request) => readUntil(options.adapter.bootstrap(authorized, request), inFlight.signal),
+        ...(refreshed === undefined
+            ? {}
+            : {
+                refresh: (authorized, request) => readUntil(refreshed(authorized, request), inFlight.signal),
+            }),
+        reached: (locator, roomVersion, target) => options.adapter.reached(locator, roomVersion, target),
+    };
     let roomsListed = false;
     const scopedRefusals = new Map();
-    const sourceRefusals = new Map();
-    const declarationRefusals = new Set();
-    function modelKey(locator, attached) {
-        return `${attached} ${locator}`;
-    }
-    function modelOf(locator, attached = 'collection') {
-        return models.get(modelKey(locator, attached)) ?? NO_MODEL;
+    function modelOf(locator) {
+        return models.get(locator) ?? NO_MODEL;
     }
-    function savedModel(locator, attached) {
-        return invalidModels.has(modelKey(locator, attached))
+    function savedModel(locator) {
+        return invalidModels.has(locator)
             ? { status: 'unavailable', reason: 'revoked' }
-            : modelOf(locator, attached);
+            : modelOf(locator);
+    }
+    function composed(record) {
+        return compositionOf(record, builtIn, typedPaths);
     }
     function compositionFor(record) {
-        return compositionOf({
-            ...record,
-            model: savedModel(record.locator, 'collection'),
-            selectionModel: savedModel(record.locator, 'typed-selection'),
-        });
+        return composed({ ...record, model: savedModel(record.locator) });
     }
     let refusal = null;
     let storageLoss = null;
@@ -139,10 +157,10 @@ export function composeRuntime(options) {
     let closed = false;
     let stopping = false;
     let withdrawStream;
-    const announced = new Map();
     let underway = null;
     let streamed = null;
     let handed = false;
+    let naming = 0;
     const recovery = (options.recovery ?? createRecovery()).scope(ROOM_ATTEMPTS);
     const repairing = new Set();
     const calling = new Set();
@@ -153,15 +171,18 @@ export function composeRuntime(options) {
     let recorded = false;
     const stale = new Set();
     let generation = 0;
-    let discovering = null;
-    let opened = null;
-    const owed = new Set();
-    const reloadsDue = new Map();
+    const reloadsDue = new Set();
+    const highest = new Map();
+    const beyondHorizon = new Set();
     const lanes = new Map();
-    let roomReads = { generation, free: ROOM_READS, waiting: [] };
+    const roomLanes = new Map();
+    let roomWork = 0;
+    const roomReads = { free: ROOM_READS, waiting: [] };
     const working = new Set();
     let mutations = Promise.resolve();
+    let gathering = null;
     const roomListeners = new Set();
+    const unlistedRooms = new Set();
     const refusalListeners = new Set();
     const storageLossListeners = new Set();
     const statusListeners = new Set();
@@ -172,6 +193,8 @@ export function composeRuntime(options) {
     let withdrawConversations;
     let currencyQueued = null;
     let socketOpen = false;
+    let announced = false;
+    let missedChange = false;
     const confirmed = new Set();
     let lockGrace = null;
     const lockListeners = new Set();
@@ -181,49 +204,84 @@ export function composeRuntime(options) {
     const serviceModeListeners = new Set();
     let member = null;
     const memberListeners = new Set();
-    const prepared = 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 capacity = null;
-    const paused = new Set();
-    let rechecking = null;
+    let full = false;
+    let probing = null;
+    let testing = null;
+    const database = {
+        async ask(request) {
+            try {
+                return await options.database.ask(request);
+            }
+            catch (error) {
+                if (refusedForSpace(error))
+                    filled();
+                throw error;
+            }
+        },
+    };
     const readinessWatches = new Set();
     let readinessQueued = false;
     const catching = new Set();
     const transfers = new FencedMap(isFenced);
+    const installs = new Set();
+    const arrivals = new Map();
+    const streaming = new Set();
+    const underived = new Map();
+    const unindexed = new Map();
+    const startedOver = new Map();
+    let arrivalReported = 0;
+    let streamsFree = STREAMS_HELD;
+    let queuedText = 0;
+    const installWaiters = [];
+    const stageBudget = {
+        bytes: STAGE_FLOOR * 4,
+        floor: STAGE_FLOOR,
+        ceiling: STAGE_BYTES,
+        aim: STAGE_AIM_MS,
+    };
+    const deriveBudget = {
+        bytes: DERIVE_FLOOR * 4,
+        floor: DERIVE_FLOOR,
+        ceiling: DERIVE_BYTES,
+        aim: DERIVE_AIM_MS,
+    };
+    const installTurns = { busy: false, ahead: 0, finishing: [], starting: [] };
     const conversations = createConversationStore({
-        agents: declaredAgents,
-        documents: (declaration, after) => rowsQuery(planOf({
-            rooms: [declaration.locator],
-            types: [declaration.type],
-            select: {
-                fields: [
-                    declaration.identity,
-                    declaration.name,
-                    ...(declaration.retired === undefined ? [] : [declaration.retired]),
-                ].map((field) => `/${escapePointer(field)}`),
-            },
-            limit: MAXIMUM_WINDOW,
-            ...(after === undefined ? {} : { after }),
-        }, roomFacts())),
         call: (name, input) => invokeAction(name, input),
+        history: (request) => readConversationHistory(request),
         durably,
         stream: () => options.adapter.conversations,
         publish: publishChangeSet,
         online: () => connectionOf() !== 'unreachable' && refusal === null,
+        full: () => full,
         closed: () => closed,
         unanswered: resendLater,
         expired: (operation) => pastHorizon(operation),
     });
     const journal = createLog();
-    const keptFiles = openedFiles(options.database, isFenced);
-    let notifyReady = () => { };
+    const keptFiles = openedFiles(database, isFenced);
+    const holding = new Map();
+    const unholdable = new Map();
+    let readyFromStore = () => { };
     const ready = new Promise((resolve) => {
-        notifyReady = resolve;
+        readyFromStore = resolve;
+    });
+    let notifyDiscovered = () => { };
+    const firstDiscovery = new Promise((resolve) => {
+        notifyDiscovered = resolve;
     });
+    let roomsNamed = false;
+    function notifyReady() {
+        notifyDiscovered();
+        readyFromStore();
+    }
     function rememberRoomDraft(record) {
         const room = roomDrafts.get(record.locator) ?? new Map();
         room.set(record.path, record);
@@ -243,7 +301,7 @@ export function composeRuntime(options) {
             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, compositionOf(held.record)) };
+        return { ...slice, collection: collectionOf(slice.documents, composed(held.record)) };
     }
     function roomDraftOf(record, visible) {
         return structuredClone({
@@ -299,14 +357,40 @@ 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('', { presentation: app }));
-        });
+    async function writtenRoomDraft(room, path, revision, input, next) {
+        const parts = readParts(input, path);
+        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);
+        if ((current?.revision ?? null) !== revision) {
+            return staleWrite(current === undefined ? null : ((await roomDraftsOf([current]))[0] ?? null));
+        }
+        const file = parts.file === undefined
+            ? undefined
+            : await heldFile(parts.file.blob, parts.file.base === undefined
+                ? binaryBase(await visibleOf(room, [path]), path)
+                : parts.file.base);
+        const record = {
+            locator: room,
+            path,
+            revision: next,
+            parts: held(current?.parts, parts, file),
+            returned: current?.returned ?? null,
+        };
+        await local.keepRoomDraft(record, parts.file === undefined || file === undefined
+            ? []
+            : [{ key: file.localId, blob: parts.file.blob }]);
+        rememberRoomDraft(record);
+        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));
+        await local.present({ app, value: stored });
+        presentations.set(app, stored);
+        publishChangeSet(changeSet('', { presentation: app }));
     }
     function emitPresentation(app) {
         if (closed)
@@ -321,6 +405,20 @@ export function composeRuntime(options) {
             (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);
+    }
     function attention() {
         const attentionRequired = [];
         for (const record of [...roomDrafts.values()].flatMap((room) => [...room.values()])) {
@@ -332,16 +430,9 @@ export function composeRuntime(options) {
                 returned: structuredClone(record.returned),
             });
         }
-        for (const [room, refusal] of sourceRefusals)
-            attentionRequired.push({ room, refusal: structuredClone(refusal) });
         attentionRequired.sort((left, right) => {
             if (left.room !== right.room)
                 return left.room < right.room ? -1 : 1;
-            if ('refusal' in left || 'refusal' in right) {
-                if ('refusal' in left && 'refusal' in right)
-                    return 0;
-                return 'refusal' in left ? -1 : 1;
-            }
             if (left.path !== right.path)
                 return left.path < right.path ? -1 : 1;
             return 0;
@@ -353,7 +444,7 @@ export function composeRuntime(options) {
             if (reset === null || submission.reset < reset)
                 reset = submission.reset;
         }
-        return { attentionRequired, reset };
+        return { attentionRequired, unsent: unsent(), reset };
     }
     function documentsIn(locator) {
         return replicas.get(locator)?.count ?? 0;
@@ -426,7 +517,7 @@ export function composeRuntime(options) {
             const governed = governs(reach, room);
             const attached = [
                 ...(governed.collection ? [modelOf(room.locator)] : []),
-                ...(governed.selection ? [modelOf(room.locator, 'typed-selection')] : []),
+                ...(governed.selection ? [builtIn] : []),
             ];
             return {
                 locator: room.locator,
@@ -442,11 +533,26 @@ export function composeRuntime(options) {
         const value = listed();
         for (const listener of roomListeners)
             listener(value);
+        emitKnownRooms();
+    }
+    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);
+        }
     }
     function emitRefusal() {
         queueReadiness();
         for (const listener of refusalListeners)
             listener(refusal);
+        emitKnownRooms();
     }
     function emitStorageLoss() {
         queueReadiness();
@@ -467,6 +573,7 @@ export function composeRuntime(options) {
         if (closed)
             return;
         queueReadiness();
+        emitKnownRooms();
         const next = status.state === 'synced' && !conversations.current()
             ? { ...status, state: 'syncing' }
             : status;
@@ -480,9 +587,6 @@ export function composeRuntime(options) {
         if (localSaves)
             return Object.freeze({ batch, state: 'local' });
         const state = pendings.get(pendingKey(locator, batch.id));
-        if (state?.accepted !== undefined) {
-            return Object.freeze({ batch, state: 'accepted', roomVersion: state.accepted });
-        }
         return Object.freeze({ batch, ...(state?.submission ?? { state: 'waiting' }) });
     }
     function entriesOf(locator) {
@@ -501,18 +605,25 @@ export function composeRuntime(options) {
     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);
-            if (held === undefined || closed || prepared.has(locator))
+            if (held === undefined || closed || held.indexed)
                 return;
             const key = held.record.key;
-            const done = await exclusive(async () => (await openLocal()).rederive(key, REDERIVE_BATCH));
-            if (replicas.get(locator)?.record.key !== key)
+            const done = await exclusive(async () => {
+                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)
+            if (!done.done)
                 continue;
-            prepared.add(locator);
+            replicas.set(locator, { ...now, indexed: true });
             publishChangeSet(changeSet(locator, { documents: null }));
             liveQueries.recover();
             queueReadiness();
@@ -520,7 +631,7 @@ export function composeRuntime(options) {
         }
     }
     function unprepared() {
-        return [...unpreparedDemand, ...replicas.keys()].find((locator) => !prepared.has(locator) && !unpreparable.has(locator));
+        return [...unpreparedDemand, ...replicas.keys()].find((locator) => !indexed(locator) && !unpreparable.has(locator));
     }
     function unpreparedBy(locator, error) {
         unpreparable.add(locator);
@@ -581,14 +692,14 @@ export function composeRuntime(options) {
                     pending.push({ room: locator, awaits: 'acquisition' });
                 continue;
             }
-            if (!prepared.has(locator)) {
+            if (!replica.indexed) {
                 pending.push({ room: locator, awaits: 'preparation' });
                 continue;
             }
             coverage.push({
                 room: locator,
                 generation: replica.record.transfer,
-                current: !(catching.has(locator) || owed.has(locator) || transfers.has(locator)),
+                current: !(catching.has(locator) || transfers.has(locator)),
             });
             read.push({ locator, key: replica.record.key });
             for (const batch of replica.queue)
@@ -615,8 +726,6 @@ export function composeRuntime(options) {
         return { listed: named.every((room) => replicas.has(room)), rooms: named };
     }
     function roomState(locator) {
-        if (sourceRefusals.has(locator))
-            return 'refused';
         const listedRoom = discovered.get(locator);
         if (roomsListed &&
             (listedRoom === undefined ||
@@ -625,13 +734,13 @@ export function composeRuntime(options) {
             return 'unadmitted';
         if (!replicas.has(locator))
             return 'acquiring';
-        if (!prepared.has(locator))
+        if (!indexed(locator))
             return 'preparing';
         return 'complete';
     }
     function conversationCoverage(reach) {
         const declared = reach === null || reach.conversations;
-        if (!declared || options.adapter.conversations === undefined || declaredAgents() === undefined)
+        if (!declared || options.adapter.conversations === undefined)
             return 'undeclared';
         if (!conversations.known() || !conversations.current())
             return 'acquiring';
@@ -646,25 +755,50 @@ export function composeRuntime(options) {
             ? 'connected'
             : 'connecting';
     }
-    function refusedIn(locators) {
-        return locators.flatMap((room) => {
-            const held = sourceRefusals.get(room);
-            if (held === undefined)
-                return [];
-            const { file, location } = held.fields;
-            return [
-                {
-                    room,
-                    file: typeof file === 'string' ? file : '',
-                    rule: held.code,
-                    location: typeof location === 'string' ? location : null,
-                },
-            ];
-        });
+    function bytesOf(room, underway) {
+        const transfer = transfers.get(room);
+        if (transfer !== undefined) {
+            const owed = (unindexed.get(room) ?? []).reduce((sum, part) => sum + part.bytes, 0);
+            return {
+                done: transfer.done.bytes - Math.ceil(owed),
+                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 };
+    }
+    function installationOf(coverage) {
+        const rooms = { done: 0, total: 0 };
+        const bytes = { done: 0, total: 0 };
+        let installing = 0;
+        let downloading = false;
+        for (const { room, state } of coverage) {
+            if (state === 'unadmitted')
+                continue;
+            rooms.total += 1;
+            if (state === 'complete')
+                rooms.done += 1;
+            const underway = state === 'acquiring' || (installs.has(room) && state !== 'complete');
+            if (underway)
+                installing += 1;
+            if (underway && (streaming.has(room) || !arrivals.has(room)))
+                downloading = true;
+            const now = bytesOf(room, underway);
+            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);
+        }
+        const step = installing === 0
+            ? null
+            : downloading
+                ? 'downloading'
+                : bytes.done < bytes.total
+                    ? 'writing'
+                    : 'replaying';
+        return { step, rooms, bytes };
     }
     function readinessFor(port, reach) {
         const required = requiredRooms(reach);
-        const search = port.search === 'required';
         const coverage = required.rooms.map((room) => ({ room, state: roomState(room) }));
         const preparing = coverage
             .filter((room) => room.state === 'preparing' && !unpreparable.has(room.room))
@@ -677,23 +811,21 @@ export function composeRuntime(options) {
                 listed: required.listed,
                 rooms: coverage,
                 conversations: conversationCoverage(reach),
-                search: search ? 'required' : 'unused',
             },
             persistence,
             connection: connectionOf(),
             house: refusal !== null ? 'refused' : writesHeld() ? 'write-halted' : 'open',
-            capacity: capacity !== null &&
-                coverage.some(({ room, state }) => paused.has(room) || !SETTLED_ROOMS.has(state))
-                ? capacity
-                : port.capacity,
-            refused: refusedIn(required.rooms),
+            space: full ? 'full' : null,
+            installation: installationOf(coverage),
             lost: storageLoss !== null,
-            established: targets[port.target]?.established === true,
+            established: targets[port.target]?.established === true ||
+                (usableWhenHeld.includes(port.target) && required.rooms.some((room) => reopened.has(room))),
         });
     }
     function establish(name) {
         targets = { ...targets, [name]: { established: true } };
         queueReadiness();
+        probeEachMinute();
         void durably((local) => local.fact('targets', targets)).catch(() => {
             journal.record(`target record failed ${name}`);
         });
@@ -731,87 +863,56 @@ export function composeRuntime(options) {
             readinessWatches.delete(watch);
         };
     }
-    function pageBytes(page) {
-        let bytes = 0;
-        for (const { path, content } of page.entries)
-            bytes += (path.length + (content?.length ?? 0)) * 2;
-        return bytes;
-    }
-    function exceeded(error) {
-        return (typeof error === 'object' &&
-            error !== null &&
-            error.name === 'QuotaExceededError');
-    }
-    async function estimated() {
-        const estimate = options.shell.estimate === undefined ? null : await options.shell.estimate();
-        return estimate === null ? null : Math.max(0, estimate.total - estimate.usage);
-    }
-    function pause(locator, cause) {
-        paused.add(locator);
-        capacity = cause;
-        journal.record(`capacity ${cause.cause} ${locator} ${cause.needed} ${cause.available ?? '-'}`);
-        queueReadiness();
-        if (rechecking !== null)
+    function filled() {
+        if (full || closed)
             return;
-        // A paused preparation measures the browser's space again each minute, so space freed elsewhere resumes it without a retry.
-        rechecking = setInterval(() => {
-            void recheck();
-        }, 60_000);
+        full = true;
+        journal.record('space full');
+        queueReadiness();
+        probeEachMinute();
     }
-    async function recheck() {
-        const held = capacity;
-        if (held === null || closed)
-            return;
-        const available = await estimated().catch(() => null);
-        if (available === null || available < (held.needed ?? 0))
-            return;
-        if (held.cause === 'storage-exceeded' &&
-            (held.available === null || available <= held.available))
-            return;
-        resume();
+    function installedTarget() {
+        return ((usableWhenHeld.length > 0 && reopened.size > 0) ||
+            Object.values(targets).some((target) => target.established));
     }
-    function resume() {
-        if (rechecking !== null)
-            clearInterval(rechecking);
-        rechecking = null;
-        if (paused.size === 0 && capacity === null)
+    function probeEachMinute() {
+        if (!full || probing !== null || closed || !installedTarget())
             return;
-        paused.clear();
-        capacity = null;
-        journal.record('capacity resumed');
-        queueReadiness();
-        if (!closed && authorization !== undefined)
-            void sync('unstreamed');
-    }
-    async function reclaimed(local) {
-        const unreferenced = [...transfers.keys()].filter((locator) => !discovered.has(locator));
-        for (const locator of unreferenced) {
-            await local.abandon(locator);
-            transfers.delete(locator);
-        }
-        if (unreferenced.length > 0)
-            journal.record(`capacity reclaimed ${unreferenced.length}`);
-        return unreferenced.length > 0;
+        // A device whose storage filled after its install tries a write each minute, so space freed elsewhere ends its read-only mode without a Retry.
+        probing = setInterval(() => {
+            void probed();
+        }, 60_000);
     }
-    async function admitted(local, locator, needed) {
-        if (paused.has(locator))
-            return false;
-        let available = await estimated().catch(() => null);
-        if (available === null || available >= needed)
-            return true;
-        if (await reclaimed(local))
-            available = await estimated().catch(() => null);
-        if (available === null || available >= needed)
+    function probed() {
+        testing ??= database.ask({ kind: 'space.probe' }).then(() => {
+            testing = null;
+            spaceFreed();
             return true;
-        pause(locator, { cause: 'insufficient-space', needed, available });
-        return false;
+        }, () => {
+            testing = null;
+            return false;
+        });
+        return testing;
     }
-    async function exceededOn(locator, bytes) {
-        const available = await estimated().catch(() => null);
-        pause(locator, { cause: 'storage-exceeded', needed: bytes, available });
+    function spaceFreed() {
+        if (!full)
+            return;
+        full = false;
+        if (probing !== null)
+            clearInterval(probing);
+        probing = null;
+        unpreparable.clear();
+        journal.record('space freed');
+        queueReadiness();
+        if (closed || authorization === undefined)
+            return;
+        if (options.adapter.roomStream === undefined)
+            void sync('unstreamed', null);
+        else
+            void resynchronize();
     }
     function seedRoomHeld(room, version) {
-        return prepared.has(room) && reachedBy(room, version);
+        return indexed(room) && reachedBy(room, version);
     }
     function seedHeld(at) {
         return Object.entries(at).every(([room, version]) => (roomsListed && !rooms.has(room)) || seedRoomHeld(room, version));
@@ -848,7 +949,24 @@ export function composeRuntime(options) {
     function sameCover(left, right) {
         return JSON.stringify(left) === JSON.stringify(right);
     }
+    async function unheldRows(local, plan, rows, rooms) {
+        if (plan.shape.kind !== 'documents' || !bodied(plan.shape))
+            return [];
+        if (!('documents' in rows) || !textOnline())
+            return [];
+        const named = new Map();
+        for (const { room, path, textHeld } of rows.documents) {
+            if (textHeld === false)
+                named.set(room, [...(named.get(room) ?? []), path]);
+        }
+        const unheld = [];
+        for (const { locator, key } of rooms) {
+            unheld.push(...(await unheldIn(local, locator, key, named.get(locator) ?? [])));
+        }
+        return unheld.filter((one) => unholdable.get(textKey(one)) !== one.revision);
+    }
     async function coveredRows(plan, cover) {
+        const asked = new Set();
         for (;;) {
             const before = cover();
             if ('pending' in before)
@@ -859,8 +977,14 @@ export function composeRuntime(options) {
             const current = () => local.changes(keys) === changes;
             const rows = await windowRows(local, plan, before.rooms, current);
             const after = cover();
-            if (rows !== null && sameCover(before, after))
+            if (rows === null || !sameCover(before, after))
+                continue;
+            const unheld = (await unheldRows(local, plan, rows, before.rooms)).filter((one) => !asked.has(textKey(one)));
+            if (unheld.length === 0)
                 return { rows, cover: before, current };
+            for (const one of unheld)
+                asked.add(textKey(one));
+            await holdTexts(unheld);
         }
     }
     async function windowRows(local, plan, rooms, unchanged) {
@@ -934,6 +1058,10 @@ export function composeRuntime(options) {
     }
     function publishChangeSet(set) {
         applyChangeSet(set);
+        for (const { locator, path } of set.documents) {
+            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();
@@ -952,6 +1080,8 @@ export function composeRuntime(options) {
     }
     async function refuse(reason, provider = null) {
         discoveryPaused = true;
+        inFlight.abort();
+        inFlight = new AbortController();
         try {
             if (reason === 'revoked-authorization') {
                 await exclusive(async () => {
@@ -959,27 +1089,24 @@ export function composeRuntime(options) {
                     const records = [...replicas].map(([locator, held]) => ({
                         locator,
                         held,
-                        record: { ...held.record, model: revoked, selectionModel: revoked },
+                        record: { ...held.record, model: revoked },
                     }));
+                    let answer = null;
                     try {
                         const local = await openLocal();
-                        await local.commit({
+                        answer = await local.commit({
                             rooms: records.map(({ locator, record }) => ({
                                 locator,
                                 key: record.key,
                                 record: storedRecord(record),
-                                composition: compositionOf(record),
+                                composed: composedOf(composed(record)),
                             })),
                         });
                     }
                     catch {
                         journal.record('model revocation persistence failed');
                     }
-                    const keys = new Set(models.keys());
-                    for (const locator of rooms.keys()) {
-                        keys.add(modelKey(locator, 'collection'));
-                        keys.add(modelKey(locator, 'typed-selection'));
-                    }
+                    const keys = new Set([...models.keys(), ...rooms.keys()]);
                     for (const key of keys) {
                         invalidModels.add(key);
                         models.set(key, revoked);
@@ -989,8 +1116,8 @@ export function composeRuntime(options) {
                     for (const { locator, held, record } of records) {
                         if (replicas.get(locator) !== held)
                             continue;
-                        recomposed(locator, held.record, record);
-                        replicas.set(locator, { ...held, record });
+                        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);
@@ -1034,15 +1161,15 @@ export function composeRuntime(options) {
                 ? null
                 : {
                     roots: selection.roots,
-                    model: modelTypes(modelOf(room.locator, 'typed-selection')),
+                    model: modelTypes(builtIn),
                 },
             providerOwnedPaths: room.providerOwnedPaths,
             roomVersion: replicas.get(room.locator)?.record.roomVersion ?? null,
             synchronizationAvailable,
-            refusal: scopedRefusals.get(room.locator) ?? sourceRefusals.get(room.locator) ?? null,
+            refusal: scopedRefusals.get(room.locator) ?? null,
         });
     }
-    async function applyDiscovery(found, started, covered) {
+    async function applyDiscovery(found, started, left) {
         const lockedBefore = lockedRooms();
         for (const room of found) {
             const fence = fences.get(room.locator);
@@ -1056,18 +1183,11 @@ export function composeRuntime(options) {
         const listedLocators = new Set(listed.map((room) => room.locator));
         for (const locator of listedLocators)
             scopedRefusals.delete(locator);
-        if (covered === undefined)
+        if (left === 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))).filter((locator) => covered === undefined || covered.includes(locator));
-        if (options.adapter.exhaustiveDiscovery === true)
-            await loseRooms(unlisted);
-        else
-            unlistedKept(unlisted);
+        await loseRooms(left ?? unlistedHeld(new Set(found.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) {
@@ -1098,15 +1218,6 @@ export function composeRuntime(options) {
             ]),
         ].filter((locator) => !listed.has(locator));
     }
-    function unlistedKept(unlisted) {
-        for (const locator of unlisted) {
-            const held = replicas.get(locator)?.record;
-            if (held !== undefined)
-                list(held, false);
-            else
-                rooms.delete(locator);
-        }
-    }
     function fence(locators) {
         const fresh = [...new Set(locators)].filter((locator) => !fences.has(locator));
         const removed = fresh.map((locator) => ({
@@ -1117,31 +1228,29 @@ export function composeRuntime(options) {
             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) ?? [])
+            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);
-            transfers.delete(locator);
+            attachedFiles.delete(locator);
+            untransferred(locator);
+            startedOver.delete(locator);
             catching.delete(locator);
             discovered.delete(locator);
-            announced.delete(locator);
             unreadable.delete(locator);
             stale.delete(locator);
             repairable.delete(locator);
             unpreparable.delete(locator);
-            paused.delete(locator);
-            prepared.delete(locator);
             scopedRefusals.delete(locator);
-            sourceRefusals.delete(locator);
-            declarationRefusals.delete(locator);
-            for (const attached of ['collection', 'typed-selection']) {
-                const key = modelKey(locator, attached);
-                models.delete(key);
-                liveModels.delete(key);
-                invalidModels.delete(key);
-            }
+            models.delete(locator);
+            liveModels.delete(locator);
+            invalidModels.delete(locator);
             journal.record(`room lost ${locator}`);
         }
         if (fresh.length === 0)
@@ -1189,7 +1298,14 @@ export function composeRuntime(options) {
         });
         await eraseFenced(fresh);
     }
-    function restored(key, persisted) {
+    function retyped(persisted) {
+        if (persisted.status === 'unavailable')
+            return persisted;
+        const { state } = attachedModel({ kind: 'model', snapshot: persisted.snapshot }, NO_MODEL, roomTypes);
+        return state.status === 'unavailable' ? state : { ...persisted, types: state.types };
+    }
+    function restored(key, held) {
+        const persisted = retyped(held);
         const prior = models.get(key);
         if (prior !== undefined &&
             prior.status !== 'unavailable' &&
@@ -1220,8 +1336,9 @@ export function composeRuntime(options) {
         const queuedBatches = new Map(queues.map((queue) => [queue.locator, queue.pending.map(({ batch }) => batch)]));
         targets = held.targets;
         transfers.clear();
-        for (const [locator, record] of held.transfers)
-            transfers.set(locator, record);
+        arrivals.clear();
+        streaming.clear();
+        startedOver.clear();
         limits = held.providerLimits;
         capabilities = held.capabilities;
         member = held.member;
@@ -1231,15 +1348,16 @@ export function composeRuntime(options) {
         presentations.clear();
         for (const record of held.presentation)
             presentations.set(record.app, record.value);
-        conversations.hydrate(heldConversations, chatDrafts);
+        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();
-        prepared.clear();
+        reopened.clear();
         queuesWithoutReplica.clear();
         for (const [locator, queue] of queuedBatches) {
             if (!held.rooms.has(locator))
@@ -1248,39 +1366,40 @@ export function composeRuntime(options) {
         records.forEach((stored, index) => {
             if (fences.has(stored.locator))
                 return;
-            const model = restored(modelKey(stored.locator, 'collection'), stored.model);
-            const selectionModel = restored(modelKey(stored.locator, 'typed-selection'), stored.selectionModel);
-            const record = { ...stored, model, selectionModel };
+            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),
             });
-            if (!held.unprepared.has(record.key))
-                prepared.add(record.locator);
             const existing = rooms.get(record.locator);
             if (existing === undefined)
-                list(record, false);
+                list(record, record.roomVersion !== null);
             else {
                 rooms.set(record.locator, {
                     ...existing,
                     roomVersion: record.roomVersion,
                     operations: record.operations,
                     replica: record.replica,
-                    model: modelTypes(model),
+                    model: modelTypes(record.model),
                     typedSelection: record.typedSelection === null
                         ? null
-                        : {
-                            roots: record.typedSelection.roots,
-                            model: modelTypes(selectionModel),
-                        },
+                        : { roots: record.typedSelection.roots, model: modelTypes(builtIn) },
                 });
             }
         });
-        for (const key of held.orphans)
-            await opened.release(key);
+        try {
+            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);
         return {
@@ -1305,7 +1424,7 @@ export function composeRuntime(options) {
     async function open() {
         if (closed)
             throw new Error('runtime closed');
-        const opened = openRuntimeStore(isFenced, options.database);
+        const opened = openRuntimeStore(isFenced, database);
         const interrupted = await opened.fences();
         for (const locator of interrupted) {
             fences.set(locator, { at: discoveries, erased: false });
@@ -1351,10 +1470,29 @@ export function composeRuntime(options) {
         return opening;
     }
     function exclusive(work) {
+        gathering = null;
         const next = mutations.then(work, work);
         mutations = next.then(() => undefined, () => undefined);
         return next;
     }
+    function gathered(key, input, merge, work) {
+        const tail = gathering;
+        if (tail !== null && tail.key === key) {
+            const merged = merge(tail.input, input);
+            if (merged !== null) {
+                tail.input = merged;
+                return tail.done;
+            }
+        }
+        const entry = { key, input, done: Promise.resolve() };
+        entry.done = exclusive(() => {
+            if (gathering === entry)
+                gathering = null;
+            return work(entry.input);
+        });
+        gathering = entry;
+        return entry.done;
+    }
     function withdrawable(locator) {
         return (batch) => {
             const state = pendings.get(pendingKey(locator, batch.id));
@@ -1363,6 +1501,16 @@ export function composeRuntime(options) {
     }
     const REWRITE_LINKS = ['field', 'body'];
     const CHECKED_LINKS = ['field', 'section'];
+    const BODY_LINKS = ['body'];
+    async function textsNeeded(local, record, named) {
+        const paths = [...new Set(named.map((one) => (typeof one === 'string' ? one : one.path)))];
+        const unheld = await unheldIn(local, record.locator, record.key, paths);
+        if (unheld.length === 0)
+            return null;
+        await holdTexts(unheld);
+        const [first] = await unheldIn(local, record.locator, record.key, unheld.map(({ path }) => path));
+        return first?.path ?? null;
+    }
     async function sliceAt(record, view, queue, extra = [], moved = []) {
         const local = await openLocal();
         const needed = new Set([...touchedBy(queue), ...extra]);
@@ -1436,26 +1584,14 @@ export function composeRuntime(options) {
             },
         };
     }
-    function recomposed(locator, before, after) {
-        if (before !== undefined &&
-            before.key === after.key &&
-            fingerprint(compositionOf(before)) === fingerprint(compositionOf(after))) {
-            return;
-        }
-        if (before !== undefined && before.key === after.key)
-            prepared.delete(locator);
-    }
-    function committedRoom(locator, record, answer) {
-        if (answer.prepared[locator] === false)
-            prepared.delete(locator);
-        else if (answer.prepared[locator] === true)
-            prepared.add(locator);
-        if (!prepared.has(locator))
+    function committedRoom(locator, answer) {
+        const indexed = answer.indexed[locator] ?? replicas.get(locator)?.indexed ?? false;
+        if (!indexed)
             prepare([locator]);
-        return { count: answer.counts[locator] ?? replicas.get(locator)?.count ?? 0 };
+        return { count: answer.counts[locator] ?? replicas.get(locator)?.count ?? 0, indexed };
     }
     function replayed(record, confirmedLayer, queue) {
-        return stepped(replaying(confirmedLayer, queue, record.locator, compositionOf(record)));
+        return stepped(replaying(confirmedLayer, queue, record.locator, composed(record)));
     }
     async function overlayDiff(record, before, visible, touched) {
         const kept = before !== undefined && before.record.key === record.key
@@ -1475,8 +1611,6 @@ export function composeRuntime(options) {
     function unpairedIn(locator, batch) {
         if (!queueIn(locator).some((held) => held.id === batch.id))
             return false;
-        if (pendings.get(pendingKey(locator, batch.id))?.accepted !== undefined)
-            return false;
         return !leavingIn(batch, locator) || withdrawable(locator)(batch);
     }
     async function together(local, settlements) {
@@ -1518,11 +1652,17 @@ export function composeRuntime(options) {
         const confirmedLayer = overrides === undefined
             ? read
             : await stepped(slicingWith(read, overrides.set, overrides.removed));
-        const composition = compositionOf(record);
-        const { withdrawn, kept } = await stepped(standing(confirmedLayer, queue, withdrawable(locator), localSaves, locator, composition));
-        const founded = kept.filter((batch) => !queue.includes(batch));
+        const composition = composed(record);
+        const shown = queue.filter((batch) => {
+            const held = landedAhead.get(pendingKey(locator, batch.id));
+            return (held !== undefined &&
+                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 founded = kept.filter((batch) => !unshown.includes(batch));
         const queueChanged = kept.length !== previousQueue.length || founded.length > 0;
-        const unqueued = [];
+        const unqueued = shown.map((batch) => ({ batch, landed: true }));
         for (const batch of withdrawn) {
             unqueued.push({ batch, landed: await landedWhole(locator, batch, confirmedLayer) });
         }
@@ -1561,6 +1701,7 @@ export function composeRuntime(options) {
                     key: record.key,
                     record: storedRecord(record),
                     roots: record.typedSelection?.roots ?? [],
+                    composed: composedOf(composition),
                     ...settling.commit,
                     ...(overrides === undefined
                         ? {}
@@ -1586,8 +1727,10 @@ export function composeRuntime(options) {
             commit,
             apply: (answer) => {
                 for (const batch of previousQueue) {
-                    if (!staying.has(batch.id))
-                        pendings.delete(pendingKey(locator, batch.id));
+                    if (staying.has(batch.id))
+                        continue;
+                    pendings.delete(pendingKey(locator, batch.id));
+                    landedAhead.delete(pendingKey(locator, batch.id));
                 }
                 for (const draft of written.values())
                     rememberRoomDraft(draft);
@@ -1602,14 +1745,14 @@ export function composeRuntime(options) {
                 const confirmedChanged = settling.commit?.published !== undefined ||
                     settling.commit?.refreshed === true ||
                     overrides !== undefined;
-                recomposed(locator, before?.record, record);
-                const { count } = committedRoom(locator, record, answer);
+                const { count, indexed } = committedRoom(locator, answer);
                 replicas.set(locator, {
                     record,
                     queue: kept,
                     overlaid: touched,
                     count,
                     confirmed: (before?.confirmed ?? 0) + (confirmedChanged ? 1 : 0),
+                    indexed,
                 });
                 return mergeChangeSets([
                     changeSet(locator, {
@@ -1624,110 +1767,107 @@ export function composeRuntime(options) {
         };
     }
     function adoptModels(locator, record) {
-        for (const [attached, model] of [
-            ['collection', record.model],
-            ['typed-selection', record.selectionModel],
-        ]) {
-            const key = modelKey(locator, attached);
-            models.set(key, model);
-            invalidModels.delete(key);
-            if (model.status === 'current')
-                liveModels.set(key, JSON.stringify(model.snapshot));
-            else if (model.status === 'unavailable')
-                liveModels.delete(key);
-        }
+        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) {
-        const taken = (answer, previous, attached) => {
-            if (answer === undefined)
-                return previous;
-            const { state, refused } = attachedModel(answer, previous, attached === 'collection' ? roomTypes : NO_ROOM_TYPES);
-            if (refused !== null) {
-                const where = refused.location === undefined ? '' : ` ${refused.location}`;
-                journal.record(`model invalid ${locator} ${attached} ${refused.identity} ${refused.rule}${where}`);
-            }
-            models.set(modelKey(locator, attached), state);
-            return state;
-        };
-        return {
-            collection: taken(answers?.collection, held.collection, 'collection'),
-            selection: taken(answers?.selection, held.selection, 'typed-selection'),
-        };
+        const answer = answers?.collection;
+        if (answer === undefined)
+            return held;
+        const { state, refused } = attachedModel(answer, held.collection, roomTypes);
+        if (refused !== null) {
+            const where = refused.location === undefined ? '' : ` ${refused.location}`;
+            journal.record(`model invalid ${locator} collection ${refused.identity} ${refused.rule}${where}`);
+        }
+        models.set(locator, state);
+        return { collection: state };
     }
-    function publish(local, room, record, landing, live) {
-        return exclusive(async () => {
+    function publish(local, room, reached, landing, live) {
+        const landed = exclusive(async () => {
             if (!live()) {
                 caughtUpTo(room.locator);
                 return true;
             }
             const prior = replicas.get(room.locator);
-            if (landing.kind === 'refreshed' &&
-                (prior === undefined || prior.record.key !== record.key || prior.confirmed !== landing.base)) {
-                await local.unrefresh(record.key);
+            if (!stands(room.locator, landing.from)) {
+                if (landing.kind === 'refreshed') {
+                    await local.unrefresh(reached.key);
+                    return false;
+                }
+                caughtUpTo(room.locator);
+                await abandoned(local, room.locator);
                 return false;
             }
+            const record = landing.kind === 'refreshed' && prior !== undefined
+                ? {
+                    ...prior.record,
+                    roomVersion: reached.roomVersion,
+                    ...(landing.remodelled ? { model: reached.model } : {}),
+                }
+                : reached;
             adoptModels(room.locator, record);
             const queue = prior?.queue ?? queuesWithoutReplica.get(room.locator) ?? [];
-            const roomVersion = record.roomVersion;
-            const accepted = queue.filter((batch) => {
-                const at = pendings.get(pendingKey(room.locator, batch.id))?.accepted;
-                return at !== undefined && options.adapter.reached(room.locator, roomVersion, at);
-            });
             let set;
             try {
-                set = await settle(local, room.locator, prior, record, queue.filter((batch) => !accepted.includes(batch)), landing.kind === 'refreshed'
+                set = await settle(local, room.locator, prior, record, queue, landing.kind === 'refreshed'
                     ? {
                         room: true,
                         view: 'refreshed',
-                        commit: { refreshed: true, composition: compositionOf(record) },
+                        commit: { refreshed: true },
                     }
                     : {
                         room: true,
                         view: landing.refreshed ? 'refreshed' : 'confirmed',
                         commit: {
                             published: { from: prior?.record.key ?? null },
-                            composition: compositionOf(record),
                             ...(landing.refreshed ? { refreshed: true } : {}),
                         },
                     });
             }
             catch (error) {
-                if (!exceeded(error))
+                if (!refusedForSpace(error))
                     throw error;
-                await exceededOn(room.locator, null);
                 caughtUpTo(room.locator);
                 return true;
             }
             if (landing.kind === 'bootstrapped') {
-                transfers.delete(room.locator);
+                highest.delete(room.locator);
+                beyondHorizon.delete(room.locator);
+                untransferred(room.locator);
+                startedOver.delete(room.locator);
                 catching.delete(room.locator);
-                sweep();
+                if (prior !== undefined && prior.record.key !== record.key)
+                    sweep();
+                name(room.locator);
             }
-            for (const batch of accepted)
-                pendings.delete(pendingKey(room.locator, batch.id));
             stale.delete(room.locator);
             unpreparable.delete(room.locator);
             if (unreadable.delete(room.locator))
                 scopedRefusals.delete(room.locator);
-            sourceRefusals.delete(room.locator);
-            declarationRefusals.delete(room.locator);
             list(room, true);
             publishChangeSet(set);
+            if (landing.kind === 'bootstrapped')
+                void heldAgain(room.locator);
             await unpair(local);
             moveTo({ ...status, ...attention() });
-            options.adapter.roomStream?.published(room.locator, roomVersion);
-            if (accepted.length > 0 && (replicas.get(room.locator)?.queue.length ?? 0) > 0) {
+            if (landing.kind === 'bootstrapped' && (replicas.get(room.locator)?.queue.length ?? 0) > 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) {
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
+            throw runtimeError('unknown-room', `Unknown Room ${locator}`);
         }
         return { local, replica, room };
     }
@@ -1745,12 +1885,7 @@ export function composeRuntime(options) {
         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 read = readSavedParts(named);
         const target = await savedRoom(locator);
         const saved = [];
         const files = [];
@@ -1759,7 +1894,7 @@ export function composeRuntime(options) {
         for (const { path, parts } of read) {
             const file = parts.file === undefined
                 ? undefined
-                : await heldFile(parts.file.blob, binaryBase(visible, path));
+                : await heldFile(parts.file.blob, parts.file.base === undefined ? binaryBase(visible, path) : parts.file.base);
             if (parts.file !== undefined && file !== undefined) {
                 files.push({ key: file.localId, blob: parts.file.blob });
             }
@@ -1794,13 +1929,27 @@ export function composeRuntime(options) {
         const referring = removed.length === 0
             ? []
             : (await local.referrers(record.key, 'confirmed', removed, CHECKED_LINKS)).map(({ path }) => path);
-        const confirmedLayer = await sliceAt(record, 'confirmed', replica.queue, [...paths, ...referring], moved);
+        const unheld = await textsNeeded(local, record, [
+            ...paths,
+            ...referring,
+            ...(moved.length === 0
+                ? []
+                : await local.referrers(record.key, 'confirmed', moved, REWRITE_LINKS)),
+            ...(removed.length === 0
+                ? []
+                : await local.referrers(record.key, 'confirmed', removed, BODY_LINKS)),
+        ]);
+        if (unheld !== null) {
+            return { refusal: { code: 'transport-uncertainty', retryable: true, file: unheld } };
+        }
+        const confirmedLayer = await sliceAt(record, 'confirmed', replica.queue, [...paths, ...paths.flatMap(ancestors), ...referring], moved);
         const { visible } = await replayed(record, confirmedLayer, replica.queue);
-        const composition = compositionOf(record);
+        const composition = composed(record);
         return {
             record,
             confirmed: confirmedLayer,
             visible,
+            folders: new Set(await local.folders(record.key, 'visible', paths)),
             *visibleOver(queue) {
                 return (yield* replaying(confirmedLayer, queue, record.locator, composition)).visible;
             },
@@ -1812,13 +1961,7 @@ export function composeRuntime(options) {
             return false;
         const local = await openLocal();
         const roots = record.typedSelection?.roots ?? [];
-        if (composition.model.status === 'unavailable' &&
-            (await local.typedWithin(record.key, 'visible', roots, false))) {
-            return true;
-        }
-        return (composition.selection !== null &&
-            composition.selection.model.status === 'unavailable' &&
-            (await local.typedWithin(record.key, 'visible', roots, true)));
+        return local.typedWithin(record.key, 'visible', roots, false);
     }
     function textDiffers(left, right) {
         return ((left?.content ?? undefined) !== (right?.content ?? undefined) ||
@@ -1829,18 +1972,6 @@ export function composeRuntime(options) {
             return undefined;
         return entry.binary !== null ? null : entry.content;
     }
-    function walkOf(local, key, view) {
-        return async (after) => {
-            const page = await local.walk(key, view, after, WALK_BYTES);
-            return {
-                entries: page.entries.map(({ path, content, binary }) => ({
-                    path,
-                    content: binary !== null ? null : content,
-                })),
-                next: page.next,
-            };
-        };
-    }
     function lookupOf(local, key, view) {
         return async (paths) => {
             if (paths.length === 0)
@@ -1857,37 +1988,6 @@ export function composeRuntime(options) {
         const read = parseFrontmatter(entry.content ?? '');
         return { type: read.ok ? (read.frontmatter.type ?? 'any') : undefined, binary: false };
     }
-    function overriddenWalk(walk, overrides) {
-        const sorted = [...overrides.keys()].sort();
-        const beyond = (path) => {
-            if (path === null)
-                return 0;
-            let low = 0;
-            let high = sorted.length;
-            while (low < high) {
-                const middle = (low + high) >>> 1;
-                if (sorted[middle] <= path)
-                    low = middle + 1;
-                else
-                    high = middle;
-            }
-            return low;
-        };
-        return async (after) => {
-            const page = await walk(after);
-            const end = page.next;
-            const added = sorted
-                .slice(beyond(after), end === null ? sorted.length : beyond(end))
-                .flatMap((path) => {
-                const entry = overrides.get(path);
-                return entry === null || entry === undefined
-                    ? []
-                    : [{ path, content: entry.binary !== null ? null : entry.content }];
-            });
-            const entries = [...page.entries.filter(({ path }) => !overrides.has(path)), ...added].sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
-            return { entries, next: end };
-        };
-    }
     function overriddenLookup(lookup, overrides) {
         return async (paths) => {
             const known = new Map(await lookup(paths.filter((path) => !overrides.has(path))));
@@ -1905,9 +2005,8 @@ export function composeRuntime(options) {
     }
     function validatorOf(record, confirmedLayer) {
         return async (resulting, touched) => {
-            const composition = compositionFor(record);
             const local = await openLocal();
-            const changed = [];
+            const changes = [];
             const overrides = new Map();
             const pace = paced();
             for (const path of new Set([...confirmedLayer.held, ...touched])) {
@@ -1918,19 +2017,13 @@ export function composeRuntime(options) {
                     continue;
                 overrides.set(path, now);
                 if (textOf(was) !== textOf(now))
-                    changed.push({ path, was: textOf(was), now: textOf(now) });
+                    changes.push({ path, was: textOf(was), now: textOf(now) });
             }
-            const lookup = overriddenLookup(lookupOf(local, record.key, 'confirmed'), overrides);
-            const clean = available(composition) &&
-                changed.length <= CLEAN_CHANGES &&
-                (await changedCleanly(changed, compositionOf(record), composition, {
-                    lookup,
-                    texts: textsOf(local, record.key, 'confirmed'),
-                    referrers: referrersOf(local, record.key, 'confirmed'),
-                }));
-            if (clean)
-                return { verdict: 'accept' };
-            return validatedCollection(overriddenWalk(walkOf(local, record.key, 'confirmed'), overrides), lookup, composition);
+            return validatedNeighbourhood(changes, compositionFor(record), {
+                lookup: overriddenLookup(lookupOf(local, record.key, 'confirmed'), overrides),
+                texts: textsOf(local, record.key, 'confirmed'),
+                referrers: referrersOf(local, record.key, 'confirmed'),
+            });
         };
     }
     function textsOf(local, key, view) {
@@ -1954,6 +2047,7 @@ export function composeRuntime(options) {
             operations: room.operations,
             providerOwnedPaths: room.providerOwnedPaths,
             visible: saving.visible,
+            folders: saving.folders,
             queued: queuedDocuments(replica.queue),
             unmodeled: await unmodeledIn(record),
             validate: validatorOf(record, saving.confirmed),
@@ -1974,6 +2068,7 @@ export function composeRuntime(options) {
                 locator,
                 key: saving.record.key,
                 roots: saving.record.typedSelection?.roots ?? [],
+                composed: composedOf(composed(saving.record)),
                 overlay: diff.overlay,
             });
         }
@@ -2005,15 +2100,19 @@ export function composeRuntime(options) {
         }
         const moves = saved.map(({ path, parts }) => ({ path, to: moveTarget(parts.move) }));
         const sourceSaving = await savingIn(replica, moves.map(({ path }) => ({ kind: 'remove', path })), saved.map(({ path }) => path), moves.map(({ path }) => path));
-        const changed = saved.flatMap(({ path, parts }) => changedParts(path, underneath(parts, path, sourceSaving.visible)));
+        if ('refusal' in sourceSaving)
+            return { outcome: 'refused', ...sourceSaving.refusal };
+        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) {
-            throw runtimeError('room-not-held', `No Local Replica for ${destination}`);
+            throw runtimeError('unknown-room', `Unknown Room ${destination}`);
         }
         const arriving = await savingIn(target, [], moves.map(({ to }) => to));
+        if ('refusal' in arriving)
+            return { outcome: 'refused', ...arriving.refusal };
         const built = await buildMove({
             source: await sideOf(locator, replica, room, sourceSaving),
             destination: await sideOf(destination, target, listedRoom, arriving),
@@ -2074,10 +2173,10 @@ export function composeRuntime(options) {
             return { outcome: 'refused', code: 'durable-write', retryable: true };
         const { answer, touched } = committedBoth;
         if (answer.fenced !== null) {
-            throw runtimeError('room-not-held', `No Local Replica for ${answer.fenced}`);
+            throw runtimeError('unknown-room', `Unknown Room ${answer.fenced}`);
         }
         if (fences.has(locator) || fences.has(destination)) {
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
+            throw runtimeError('unknown-room', `Unknown Room ${locator}`);
         }
         pendings.set(pendingKey(locator, id), {
             drafts: saved,
@@ -2117,6 +2216,8 @@ export function composeRuntime(options) {
         submitLater(locator);
     }
     async function committed(locator, target, saved, consumed, writtenBy, files = []) {
+        if (full)
+            return { outcome: 'refused', code: 'durable-write', retryable: true };
         const into = movedInto(locator, saved);
         if (into !== null) {
             return committedMove(locator, into, target, saved, consumed, writtenBy, files);
@@ -2128,7 +2229,9 @@ export function composeRuntime(options) {
             ...saved.map(({ path }) => path),
             ...parts.flatMap(({ bases }) => bases.map(({ path }) => path)),
         ]);
-        const changed = saved.flatMap(({ path, parts: held }) => changedParts(path, underneath(held, path, saving.visible)));
+        if ('refusal' in saving)
+            return { outcome: 'refused', ...saving.refusal };
+        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));
@@ -2156,6 +2259,7 @@ export function composeRuntime(options) {
             providerLimits: limits,
             handle: room.handle,
             visible: saving.visible,
+            folders: saving.folders,
             changes,
             bases: parts.flatMap(({ bases }) => bases),
             queued: queuedDocuments(replica.queue),
@@ -2245,10 +2349,10 @@ export function composeRuntime(options) {
             return { outcome: 'refused', code: 'durable-write', retryable: true };
         const { answer, touched } = done;
         if (answer.fenced !== null) {
-            throw runtimeError('room-not-held', `No Local Replica for ${answer.fenced}`);
+            throw runtimeError('unknown-room', `Unknown Room ${answer.fenced}`);
         }
         if (fences.has(locator))
-            throw runtimeError('room-not-held', `No Local Replica for ${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) {
@@ -2297,7 +2401,7 @@ export function composeRuntime(options) {
             throw new Error('connection refused');
         await local.keepUpload(locator, identifier, upload);
         if (fences.has(locator))
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
+            throw runtimeError('unknown-room', `Unknown Room ${locator}`);
         const key = pendingKey(locator, identifier);
         pendings.set(key, { ...pendings.get(key), upload });
         if (!continuing())
@@ -2306,6 +2410,9 @@ export function composeRuntime(options) {
     async function readHistory(locator, path, query = {}) {
         if (closed || refusal !== null)
             return UNCERTAIN;
+        await firstDiscovery;
+        if (!roomsNamed)
+            return UNCERTAIN;
         try {
             await ensureAuthorization();
         }
@@ -2395,14 +2502,12 @@ export function composeRuntime(options) {
             return (await openLocal()).file(localId, change?.kind === 'binary' ? change.mediaType : '');
         };
     }
-    function binaryRoom(request) {
-        if (request.kind === 'path')
-            return request.locator;
-        return options.adapter.referrerScope(request.referrer)?.locator ?? null;
-    }
     async function transferBinary(request, transfer, answer) {
         if (closed || refusal !== null)
             return UNCERTAIN;
+        await firstDiscovery;
+        if (!roomsNamed)
+            return UNCERTAIN;
         try {
             await ensureAuthorization();
         }
@@ -2412,16 +2517,13 @@ export function composeRuntime(options) {
         if (closed || authorization === undefined || refusal !== null)
             return UNCERTAIN;
         const since = fencings;
-        journal.record(request.kind === 'path'
-            ? `transfer binary ${request.locator} ${request.path}`
-            : `transfer binary ${request.fileRef}`);
+        journal.record(`transfer binary ${request.locator} ${request.path}`);
         try {
             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 (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;
                 if (room !== undefined)
@@ -2436,23 +2538,104 @@ export function composeRuntime(options) {
             return UNCERTAIN;
         }
     }
+    async function heldAgain(locator) {
+        const replica = replicas.get(locator);
+        if (replica === undefined || !textOnline())
+            return;
+        try {
+            const wanted = await (await openLocal()).wanted(locator, replica.record.key);
+            await holdTexts(wanted.map(({ path, revision }) => ({ locator, path, revision })));
+        }
+        catch {
+            journal.record(`hold text ${locator} unwritten`);
+        }
+    }
+    function textOnline() {
+        return !closed && refusal === null && connectionOf() === 'connected';
+    }
+    function textKey({ locator, path }) {
+        return documentKey(locator, path);
+    }
+    async function readText({ locator, path, revision }) {
+        const replica = replicas.get(locator);
+        if (replica === undefined || !textOnline())
+            return;
+        try {
+            await ensureAuthorization();
+        }
+        catch {
+            return;
+        }
+        if (closed || authorization === undefined || refusal !== null)
+            return;
+        const since = fencings;
+        journal.record(`hold text ${locator} ${path}`);
+        const read = await reads
+            .bootstrap(authorization, { locator, selection: replica.record.replica.selection, path })
+            .catch(() => null);
+        journal.record(`outcome text ${read?.kind ?? 'transport-uncertainty'}`);
+        if (read === null || read.kind !== 'bootstrap' || fencedSince(locator, since))
+            return;
+        const content = read.documents[path];
+        const now = replicas.get(locator);
+        if (content === undefined || read.revisions[path] !== revision || now === undefined) {
+            unholdable.set(textKey({ locator, path, revision }), revision);
+            return;
+        }
+        const held = await (await openLocal()).hold(locator, now.record.key, compositionFor(now.record), [{ path, revision, content }]);
+        if (held.length === 0)
+            unholdable.set(textKey({ locator, path, revision }), revision);
+        else
+            publishChangeSet(changeSet(locator, { documents: held }));
+    }
+    function holdText(unheld) {
+        const key = textKey(unheld);
+        const running = holding.get(key);
+        if (running !== undefined)
+            return running;
+        const started = readText(unheld).finally(() => holding.delete(key));
+        holding.set(key, started);
+        return started;
+    }
+    async function holdTexts(wanted) {
+        const queue = wanted.filter((one) => unholdable.get(textKey(one)) !== one.revision);
+        await Promise.all(Array.from({ length: Math.min(TEXT_READS, queue.length) }, async () => {
+            for (let next = queue.shift(); next !== undefined; next = queue.shift()) {
+                await holdText(next);
+            }
+        }));
+    }
+    async function unheldIn(local, locator, key, paths) {
+        if (paths.length === 0)
+            return [];
+        return (await local.entries(key, 'confirmed', paths)).flatMap((entry) => entry.content === null &&
+            entry.binary === null &&
+            entry.outline !== null &&
+            entry.revision !== null
+            ? [{ locator, path: entry.path, revision: entry.revision }]
+            : []);
+    }
+    function fetchBinary(request, name) {
+        return transferBinary(request, (authorization) => keptFiles.fetch(name, () => options.adapter.binary(authorization, request)), binaryAnswer);
+    }
     async function readBinary(request, name) {
         if (closed)
             return UNCERTAIN;
         const held = await keptFiles.find(name);
         if (held !== null)
             return held;
-        return transferBinary(request, (authorization) => keptFiles.fetch(name, () => options.adapter.binary(authorization, request)), binaryAnswer);
+        return fetchBinary(request, name);
     }
     async function binaryPath(locator, path, revision) {
         if (revision !== undefined)
             return { kind: 'path', locator, path, revision };
         const replica = replicas.get(locator);
-        if (replica === undefined)
-            return null;
         const local = await openLocal();
-        const [held] = await local.entries(replica.record.key, 'visible', [path]);
-        if (held?.binary === undefined || held.binary === null)
+        const [held] = replica === undefined ? [] : await local.entries(replica.record.key, 'visible', [path]);
+        const attached = held === undefined ? attachedFiles.get(locator)?.get(path) : undefined;
+        if (attached !== undefined)
+            return { kind: 'path', locator, path, revision: attached.revision };
+        if (replica === undefined || held?.binary === undefined || held.binary === null)
             return null;
         if (held.binary.state === 'pending')
             return { kind: 'pending', localId: held.binary.localId };
@@ -2468,7 +2651,7 @@ export function composeRuntime(options) {
         const holds = (at) => {
             const kept = confirmedLayer.binaries[at];
             return (kept?.state === 'accepted' &&
-                kept.fileRef === record.fileRef &&
+                kept.sha256 === record.sha256 &&
                 confirmedLayer.revisions[at] === record.revision);
         };
         let confirmedAt = path;
@@ -2482,57 +2665,101 @@ export function composeRuntime(options) {
             locator,
             path: confirmedAt,
             revision: record.revision,
-            fileRef: record.fileRef,
         };
     }
-    async function readBinaryPath(locator, path, revision) {
+    async function askedBinary(locator, path, revision) {
         await ready;
         const drafted = roomDrafts.get(locator)?.get(path)?.parts.file;
-        const asked = drafted !== undefined && drafted.localId === revision
+        return drafted !== undefined && drafted.localId === revision
             ? { kind: 'pending', localId: revision }
-            : await binaryPath(locator, path, revision);
+            : binaryPath(locator, path, revision);
+    }
+    function pendingBinary(locator, path, localId) {
+        const facts = queuedFacts(locator, path, localId);
+        return facts === null
+            ? absentBinary(path)
+            : {
+                kind: 'binary',
+                file: localId,
+                byteLength: facts.byteLength,
+                mediaType: facts.mediaType,
+            };
+    }
+    async function readBinaryPath(locator, path, revision) {
+        const asked = await askedBinary(locator, path, revision);
         if (asked === null)
             return absentBinary(path);
-        if (asked.kind === 'pending') {
-            const facts = queuedFacts(locator, path, asked.localId);
-            return facts === null
-                ? absentBinary(path)
-                : {
-                    kind: 'binary',
-                    file: asked.localId,
-                    byteLength: facts.byteLength,
-                    mediaType: facts.mediaType,
-                };
-        }
+        if (asked.kind === 'pending')
+            return pendingBinary(locator, path, asked.localId);
         return readBinary(asked, { locator, path: asked.path, revision: asked.revision });
     }
+    async function heldMediaType(locator, path) {
+        const replica = replicas.get(locator);
+        const [held] = replica === undefined
+            ? []
+            : await (await openLocal()).entries(replica.record.key, 'visible', [path]);
+        return held === undefined
+            ? attachedFiles.get(locator)?.get(path)?.mediaType
+            : held.binary?.mediaType;
+    }
+    function linkOf(asked, held) {
+        return transferBinary(asked, (authorization) => options.adapter.link(authorization, asked), (result) => binaryLinkAnswer(result, held));
+    }
     async function linkBinaryPath(locator, path, revision) {
         await ready;
         const asked = await binaryPath(locator, path, revision);
         if (asked === null || asked.kind === 'pending')
             return absentBinary(path);
-        return transferBinary(asked, (held) => options.adapter.link(held, asked), binaryLinkAnswer);
+        return linkOf(asked, revision === undefined ? await heldMediaType(locator, path) : undefined);
     }
-    async function readBinaryReference(reference) {
+    async function showBinaryPath(locator, path, revision) {
+        const asked = await askedBinary(locator, path, revision);
+        if (asked === null)
+            return absentBinary(path);
+        if (asked.kind === 'pending')
+            return pendingBinary(locator, path, asked.localId);
+        if (closed)
+            return UNCERTAIN;
+        const name = { locator, path: asked.path, revision: asked.revision };
+        const kept = await keptFiles.find(name);
+        if (kept !== null)
+            return kept;
+        const mediaType = await heldMediaType(locator, path);
+        if (mediaType?.startsWith('image/') === true)
+            return fetchBinary(asked, name);
+        return linkOf(asked, revision === undefined ? mediaType : undefined);
+    }
+    async function attachBinary(locator, file) {
         await ready;
-        const scope = options.adapter.referrerScope(reference.referrer);
-        if (scope === null)
-            return absentReference(reference.fileRef);
-        return readBinary({ kind: 'reference', fileRef: reference.fileRef, referrer: reference.referrer }, { locator: scope.locator, path: scope.path ?? '', revision: reference.fileRef });
+        await firstDiscovery;
+        if (closed || !roomsNamed || connectionOf() === 'unreachable' || refusal !== null)
+            return OFFLINE;
+        const request = await attachedFile(locator, file);
+        return transferBinary({ locator, path: file.name }, async (held) => {
+            const result = await options.adapter.attach(held, request);
+            if (result.kind === 'attached') {
+                const landed = attachedFiles.get(locator) ?? new Map();
+                landed.set(result.path, { revision: result.revision, mediaType: request.mediaType });
+                attachedFiles.set(locator, landed);
+            }
+            return result;
+        }, attachAnswer);
     }
     function readPart(file, part) {
-        return options.database.ask({ kind: 'file.part', key: file, part });
+        return database.ask({ kind: 'file.part', key: file, part });
     }
     async function cleanUp() {
-        const freed = await options.database.ask({ kind: 'opened.clean' });
-        return freed + ((await options.shell.cleanUp?.()) ?? 0);
-    }
-    function declaredAgents() {
-        for (const capability of capabilities) {
-            if (capability.conversationAgents !== undefined)
-                return capability.conversationAgents;
+        const freed = await database.ask({ kind: 'opened.clean' });
+        const local = await openLocal();
+        let texts = 0;
+        for (const [locator, replica] of replicas) {
+            const released = await local.unhold(locator, replica.record.key, compositionFor(replica.record));
+            texts += released.bytes;
+            if (released.paths.length > 0) {
+                publishChangeSet(changeSet(locator, { documents: released.paths }));
+            }
         }
-        return undefined;
+        return freed + texts + ((await options.shell.cleanUp?.()) ?? 0);
     }
     function declaredAction(name) {
         for (const capability of capabilities) {
@@ -2585,6 +2812,24 @@ export function composeRuntime(options) {
             return UNCERTAIN;
         }
     }
+    async function readConversationHistory(request) {
+        await ready;
+        const stream = options.adapter.conversations;
+        if (closed || refusal !== null || stream?.history === undefined)
+            return UNCERTAIN;
+        journal.record('transfer conversation history');
+        try {
+            const result = await stream.history(request);
+            if (result.kind === 'revoked-authorization')
+                await refuse('revoked-authorization');
+            journal.record(`outcome conversation history ${result.kind}`);
+            return calledResult(result);
+        }
+        catch {
+            journal.record('outcome conversation history transport-uncertainty');
+            return UNCERTAIN;
+        }
+    }
     function unsettled(result) {
         return result.kind !== 'action' && result.retryable;
     }
@@ -2646,6 +2891,33 @@ export function composeRuntime(options) {
         const held = replicas.get(locator);
         return (held !== undefined && options.adapter.reached(locator, held.record.roomVersion, roomVersion));
     }
+    function shownAt(locator) {
+        const held = replicas.get(locator)?.record.roomVersion;
+        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);
+        if (at === undefined || !options.adapter.reached(locator, at, roomVersion)) {
+            highest.set(locator, roomVersion);
+        }
+    }
+    function older(locator, roomVersion) {
+        if (beyondHorizon.has(locator))
+            return false;
+        const at = shownAt(locator);
+        return (at !== undefined &&
+            options.adapter.reached(locator, at, roomVersion) &&
+            !options.adapter.reached(locator, roomVersion, at));
+    }
+    function replaced(locators) {
+        for (const locator of locators) {
+            highest.delete(locator);
+            beyondHorizon.add(locator);
+        }
+    }
     async function writtenAfter(locator, roomVersion, path) {
         const held = replicas.get(locator);
         if (held === undefined)
@@ -2656,169 +2928,233 @@ export function composeRuntime(options) {
             options.adapter.reached(locator, written, roomVersion) &&
             !options.adapter.reached(locator, roomVersion, written));
     }
-    function overriddenTexts(texts, overrides) {
-        return async (paths) => {
-            const known = new Map(await texts(paths.filter((path) => !overrides.has(path))));
-            for (const path of paths) {
-                const entry = overrides.get(path);
-                if (entry === undefined)
-                    continue;
-                if (entry === null)
-                    known.delete(path);
-                else
-                    known.set(path, entry.binary !== null ? null : entry.content);
-            }
-            return known;
-        };
-    }
-    async function unreadableRoom(texts, walk, paths) {
-        if (paths !== null) {
-            const text = {};
-            for (const [path, content] of await texts(paths))
-                if (content !== null)
-                    text[path] = content;
-            return stepped(unreadableIn(text, Object.keys(text)));
-        }
-        for (let after = null;;) {
-            const page = await walk(after);
-            const text = {};
-            for (const { path, content } of page.entries)
-                if (content !== null)
-                    text[path] = content;
-            const refused = await stepped(unreadableIn(text, Object.keys(text)));
-            if (refused !== null)
-                return refused;
-            if (page.next === null)
-                return null;
-            after = page.next;
-        }
-    }
-    async function validatedRoom(local, record, view, previous, overrides = null) {
-        const composition = compositionOf(record);
-        const modeled = record.model.status !== 'unavailable' || record.selectionModel.status !== 'unavailable';
-        const lookup = overrides === null
-            ? lookupOf(local, record.key, view)
-            : overriddenLookup(lookupOf(local, record.key, view), overrides);
-        const texts = overrides === null
-            ? textsOf(local, record.key, view)
-            : overriddenTexts(textsOf(local, record.key, view), overrides);
-        const walk = overrides === null
-            ? walkOf(local, record.key, view)
-            : overriddenWalk(walkOf(local, record.key, view), overrides);
-        let changes = null;
-        let reshaped = false;
-        if (previous !== null && previous.changed.length <= CLEAN_CHANGES) {
-            const [was, now] = await Promise.all([
-                local.entries(record.key, 'confirmed', previous.changed),
-                overrides === null
-                    ? local.entries(record.key, view, previous.changed)
-                    : Promise.resolve([]),
-            ]);
-            const before = new Map(was.map((entry) => [entry.path, entry]));
-            const after = overrides === null
-                ? new Map(now.map((entry) => [entry.path, entry]))
-                : overrides;
-            changes = previous.changed.flatMap((path) => {
-                const one = before.get(path) ?? null;
-                const other = after.get(path) ?? null;
-                reshaped ||= textDiffers(one, other);
-                const held = textOf(one);
-                const next = textOf(other);
-                return held === next ? [] : [{ path, was: held, now: next }];
-            });
-        }
-        const named = changes === null ? null : changes.map(({ path }) => path);
-        const textChanged = changes === null || changes.length > 0 || reshaped;
-        const modelsChanged = previous === null || !sameComposition(compositionOf(previous.record), composition);
-        if (modeled && (textChanged || modelsChanged)) {
-            const clean = previous !== null &&
-                changes !== null &&
-                (await changedCleanly(changes, compositionOf(previous.record), composition, {
-                    lookup,
-                    texts,
-                    referrers: referrersOf(local, record.key, 'confirmed'),
-                }));
-            if (clean)
-                return null;
-            const verdict = await validatedCollection(walk, lookup, composition);
-            if (verdict.verdict === 'accept')
-                return null;
-            if (verdict.rule !== 'model-unavailable')
-                return { kind: 'refused', refusal: verdict };
-            return unreadableRoom(texts, walk, named);
-        }
-        if (textChanged)
-            return unreadableRoom(texts, walk, named);
-        return null;
+    async function writtenLater(local, locator, key, paths, roomVersion) {
+        if (paths.length === 0 || !older(locator, roomVersion))
+            return new Set();
+        const entries = await local.entries(key, 'confirmed', paths);
+        return new Set(entries.flatMap(({ path, written }) => written !== null &&
+            options.adapter.reached(locator, written, roomVersion) &&
+            !options.adapter.reached(locator, roomVersion, written)
+            ? [path]
+            : []));
     }
-    function refreshingOf(local, key, liveness) {
+    function refreshingOf(local, locator, key, composition, liveness, replaying = false) {
+        const write = replaying ? finishingWrite : exclusive;
         return {
+            turn() {
+                if (replaying)
+                    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),
             async stage(page) {
-                const batches = batched(page.entries);
-                for (const [index, entries] of batches.entries()) {
-                    const last = index === batches.length - 1;
-                    const staged = await exclusive(async () => {
+                for (let written = 0;;) {
+                    const end = batchEnd(page.entries, written);
+                    const last = end === page.entries.length;
+                    const entries = page.entries.slice(written, end);
+                    const staged = await write(async () => {
                         if (!liveness())
                             return false;
-                        await local.refresh(key, last
+                        await timed(stageBudget, () => local.refresh(key, composition, last
                             ? { ...page, entries }
-                            : { entries, removals: [], folders: [], folderRemovals: [] });
+                            : { entries, removals: [], folders: [], folderRemovals: [] }));
                         return true;
                     });
                     if (!staged)
                         return false;
+                    if (last)
+                        return true;
+                    written = end;
                 }
-                return true;
             },
         };
     }
-    function batched(entries) {
-        const batches = [[]];
+    function batchEnd(entries, from) {
+        let end = from;
         let spent = 0;
-        for (const entry of entries) {
-            const size = (entry.content?.length ?? 0) + ROW_WEIGHT;
-            if (spent + size > STAGE_BYTES && batches.at(-1).length > 0) {
-                batches.push([]);
-                spent = 0;
-            }
-            batches.at(-1).push(entry);
+        while (end < entries.length) {
+            const size = (entries[end].content?.length ?? 0) + ROW_WEIGHT;
+            if (spent + size > stageBudget.bytes && end > from)
+                break;
             spent += size;
-        }
-        return batches;
+            end += 1;
+        }
+        return end;
+    }
+    async function timed(budget, work) {
+        const started = performance.now();
+        const done = await work();
+        const spent = performance.now() - started;
+        if (spent < budget.aim / 2)
+            budget.bytes = Math.min(budget.ceiling, Math.round(budget.bytes * 1.5));
+        else if (spent > budget.aim * 2) {
+            budget.bytes = Math.max(budget.floor, Math.round(budget.bytes / 1.5));
+        }
+        return done;
+    }
+    function installWrite(work) {
+        return installTurn(installTurns.starting, work);
+    }
+    function finishingWrite(work) {
+        return installTurn(installTurns.finishing, work);
+    }
+    function installTurn(queue, work) {
+        return new Promise((resolve, reject) => {
+            queue.push(() => void exclusive(work)
+                .then(resolve, reject)
+                .finally(() => {
+                installTurns.busy = false;
+                nextInstallTurn();
+            }));
+            nextInstallTurn();
+        });
     }
-    async function pullRefresh(authorized, held, liveness) {
-        if (!liveness())
-            return unconfirmed;
-        const turn = generation;
-        const { record } = held;
-        const base = held.confirmed;
-        const local = await openLocal();
+    function nextInstallTurn() {
+        if (installTurns.busy || installTurns.ahead > 0)
+            return;
+        const turn = installTurns.finishing.shift() ?? installTurns.starting.shift();
+        if (turn === undefined)
+            return;
+        installTurns.busy = true;
+        turn();
+    }
+    async function ahead(work) {
+        let taken = false;
+        const hold = {
+            take() {
+                if (taken)
+                    return;
+                taken = true;
+                installTurns.ahead += 1;
+            },
+            release() {
+                if (!taken)
+                    return;
+                taken = false;
+                installTurns.ahead -= 1;
+                resumeInstall();
+            },
+        };
+        hold.take();
+        try {
+            return await work(hold);
+        }
+        finally {
+            hold.release();
+        }
+    }
+    function resumeInstall() {
+        if (installTurns.ahead > 0)
+            return;
+        void yielded().then(nextInstallTurn);
+    }
+    async function heldStream() {
+        while (streamsFree === 0)
+            await new Promise((admit) => installWaiters.push(admit));
+        streamsFree -= 1;
+        return once(() => {
+            streamsFree += 1;
+        });
+    }
+    async function unqueued() {
+        while (queuedText >= QUEUED_TEXT) {
+            await new Promise((admit) => installWaiters.push(admit));
+        }
+    }
+    function once(release) {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            release();
+            for (const admit of installWaiters.splice(0))
+                admit();
+        };
+    }
+    function installing(locator) {
+        installs.add(locator);
+        queueReadiness();
+    }
+    function untransferred(locator) {
+        transfers.delete(locator);
+        arrivals.delete(locator);
+        streaming.delete(locator);
+        underived.delete(locator);
+        unindexed.delete(locator);
+    }
+    function setBack(locator) {
+        const now = bytesOf(locator, true);
+        const earlier = startedOver.get(locator);
+        startedOver.set(locator, {
+            done: Math.max(now.done, earlier?.done ?? 0),
+            total: Math.max(now.total, earlier?.total ?? 0),
+        });
+    }
+    function owedIndexes(locator, bytes, text) {
+        if (bytes <= 0 || text <= 0)
+            return;
+        unindexed.set(locator, [...(unindexed.get(locator) ?? []), { bytes, text }]);
+    }
+    function built(locator, { done, text }) {
+        const owed = unindexed.get(locator) ?? [];
+        let left = text;
+        while (!done && left > 0 && owed.length > 0) {
+            const [first] = owed;
+            if (left >= first.text) {
+                left -= first.text;
+                owed.shift();
+                continue;
+            }
+            owed[0] = {
+                bytes: (first.bytes * (first.text - left)) / first.text,
+                text: first.text - left,
+            };
+            left = 0;
+        }
+        if (done || owed.length === 0)
+            unindexed.delete(locator);
+        queueReadiness();
+    }
+    function installed(locator) {
+        if (installs.delete(locator))
+            queueReadiness();
+    }
+    async function pullRefresh(authorized, held, liveness, hold, refresh) {
+        if (!liveness())
+            return unconfirmed;
+        const { record } = held;
+        const from = standingOf(record.locator);
+        const local = await openLocal();
         try {
             await exclusive(() => local.unrefresh(record.key));
-            const result = await advancement(reads, authorized, record, (models, kept) => (liveness() ? remodel(record.locator, models, kept) : kept), liveness, refreshingOf(local, record.key, liveness));
+            const result = await advancement(async (authorization, request) => {
+                hold.release();
+                try {
+                    return await refresh(authorization, request);
+                }
+                finally {
+                    hold.take();
+                }
+            }, authorized, record, (models, kept) => (liveness() ? remodel(record.locator, models, kept) : kept), liveness, refreshingOf(local, record.locator, record.key, composed(record), liveness));
             if (result.kind !== 'advanced') {
                 journal.record(`transfer refresh ${record.locator} ${result.kind}`);
                 return result;
             }
-            const refused = await validatedRoom(local, result.record, 'refreshed', {
-                record,
-                changed: [...result.changed],
-            });
-            if (refused !== null) {
-                journal.record(`transfer refresh ${record.locator} refused`);
-                return refused;
-            }
             journal.record(`transfer refresh ${record.locator} ${result.record.roomVersion}`);
-            return { kind: 'advanced', record: result.record, base };
+            return {
+                kind: 'advanced',
+                record: result.record,
+                from,
+                remodelled: result.record.model !== record.model,
+            };
         }
         catch (error) {
+            if (refusedForSpace(error))
+                return unconfirmed;
             journal.record(`transfer refresh ${record.locator} transport-uncertainty`);
             throw error;
         }
-        finally {
-            reads.finished(record.locator, turn);
-        }
     }
     const heldContents = new Map();
     function heldContentOf(local, key) {
@@ -2836,63 +3172,115 @@ export function composeRuntime(options) {
         heldContents.set(key, made);
         return made;
     }
+    async function abandoned(local, locator) {
+        await local.abandon(locator);
+        setBack(locator);
+        untransferred(locator);
+        liveQueries.recover();
+        sweep();
+    }
     function staging(local, liveness) {
+        const derived = async (locator, key, composition) => {
+            underived.delete(locator);
+            for (;;) {
+                if (!liveness())
+                    return false;
+                const done = await finishingWrite(async () => liveness()
+                    ? timed(deriveBudget, () => local.rederive(key, composition, deriveBudget.bytes, DERIVE_LONGEST_MS, DERIVE_FLOOR))
+                    : null);
+                if (done === null)
+                    return false;
+                built(locator, done);
+                if (done.done)
+                    return true;
+            }
+        };
         return {
             held: (locator) => transfers.get(locator) ?? null,
+            async turn(locator, step) {
+                installing(locator);
+                return step === 'downloading' ? heldStream() : () => { };
+            },
+            unqueued,
+            queued(text) {
+                queuedText += text;
+                return once(() => {
+                    queuedText -= text;
+                });
+            },
+            arriving(locator) {
+                let ended = false;
+                return {
+                    at(bytes) {
+                        if (ended)
+                            return;
+                        arrivals.set(locator, bytes);
+                        streaming.add(locator);
+                        const now = performance.now();
+                        if (now - arrivalReported < ARRIVAL_REPORT_MS)
+                            return;
+                        arrivalReported = now;
+                        queueReadiness();
+                    },
+                    end() {
+                        if (ended)
+                            return;
+                        ended = true;
+                        if (streaming.delete(locator))
+                            queueReadiness();
+                    },
+                };
+            },
+            streamed: options.adapter.roomStream !== undefined,
             async stage(record, page, composition) {
-                const bytes = pageBytes(page);
-                const batches = batched(page.entries);
-                let key = record.key;
-                for (const [index, entries] of batches.entries()) {
-                    const last = index === batches.length - 1;
-                    const staged = await exclusive(async () => {
-                        if (!liveness())
-                            return null;
-                        if (index === 0 && !(await admitted(local, record.locator, bytes)))
-                            return null;
-                        try {
-                            return await local.stage(record, composition, { entries, folders: last ? page.folders : [] }, key, last);
-                        }
-                        catch (error) {
-                            if (!exceeded(error))
-                                throw error;
-                            await exceededOn(record.locator, bytes);
-                            return null;
-                        }
-                    });
-                    if (staged === null)
+                const { locator } = record;
+                installing(locator);
+                if (!liveness())
+                    return null;
+                const key = await installWrite(async () => {
+                    if (!liveness())
                         return null;
-                    key = staged;
-                }
-                transfers.set(record.locator, { ...record, key });
+                    return local.stage(record, composition, page);
+                });
+                if (key === null || !liveness())
+                    return null;
+                const arrived = !transfers.has(locator);
+                const prior = transfers.get(locator)?.done.bytes ?? 0;
+                const held = { ...record, key };
+                transfers.set(locator, held);
+                if (arrived)
+                    liveQueries.recover();
+                installing(locator);
                 liveQueries.recover();
-                return key;
+                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);
+                underived.set(locator, owed);
+                if (owed < deriveBudget.bytes)
+                    return held;
+                return (await derived(locator, key, composition)) ? held : null;
             },
-            async refreshing(key) {
+            derive: derived,
+            async refreshing(locator, key, composition) {
                 await exclusive(() => local.unrefresh(key));
-                return refreshingOf(local, key, liveness);
+                return refreshingOf(local, locator, key, composition, liveness, true);
             },
             abandon: (locator) => exclusive(async () => {
-                if (!liveness())
-                    return;
-                await local.abandon(locator);
-                transfers.delete(locator);
-                liveQueries.recover();
-                sweep();
+                if (liveness())
+                    await abandoned(local, locator);
             }),
-            setAside: (locator) => exclusive(async () => {
+            setAside: async (locator) => {
                 if (!liveness())
                     return;
-                await local.abandon(locator, true);
-                transfers.delete(locator);
+                setBack(locator);
+                untransferred(locator);
                 liveQueries.recover();
-            }),
+            },
             release: (key) => exclusive(async () => {
                 await local.release(key);
                 sweep();
             }),
             content: (key) => heldContentOf(local, key),
-            validate: (record, view) => validatedRoom(local, record, view, null),
         };
     }
     function reusable(room, local) {
@@ -2904,30 +3292,35 @@ export function composeRuntime(options) {
     async function pullBootstrap(authorized, room, local, liveness) {
         if (!liveness())
             return unconfirmed;
-        const turn = generation;
         if (replicas.has(room.locator)) {
             catching.add(room.locator);
             liveQueries.recover();
         }
         try {
-            const result = await bootstrapRoom(reads, authorized, room, {
-                collection: modelOf(room.locator),
-                selection: modelOf(room.locator, 'typed-selection'),
-            }, (models, held) => (liveness() ? remodel(room.locator, models, held) : held), liveness, staging(local, liveness), reusable(room, local));
+            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 detail = result.kind === 'staged' ? result.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
-            if (result.kind !== 'staged')
+            if (result.kind === 'staged' && older(room.locator, result.record.roomVersion)) {
                 caughtUpTo(room.locator);
+                installed(room.locator);
+                await abandoned(local, room.locator);
+                journal.record(`transfer bootstrap ${room.locator} older than shown`);
+                return { kind: 'transport-uncertainty' };
+            }
+            if (result.kind !== 'staged') {
+                caughtUpTo(room.locator);
+                installed(room.locator);
+            }
             return result;
         }
         catch (error) {
-            journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
             caughtUpTo(room.locator);
+            installed(room.locator);
+            if (refusedForSpace(error))
+                return unconfirmed;
+            journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
             throw error;
         }
-        finally {
-            reads.finished(room.locator, turn);
-        }
     }
     function caughtUpTo(locator) {
         if (catching.delete(locator))
@@ -2935,72 +3328,83 @@ export function composeRuntime(options) {
     }
     function behind(room) {
         const held = replicas.get(room.locator)?.record.roomVersion;
-        return (held !== undefined &&
-            [announced.get(room.locator), room.roomVersion].some((later) => later !== undefined && !options.adapter.reached(room.locator, held, later)));
+        return held !== undefined && !options.adapter.reached(room.locator, held, room.roomVersion);
     }
-    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);
+    function standingOf(locator) {
+        const held = replicas.get(locator);
+        return { key: held?.record.key ?? null, confirmed: held?.confirmed ?? 0 };
+    }
+    function stands(locator, from) {
+        const now = standingOf(locator);
+        return now.key === from.key && now.confirmed === from.confirmed;
     }
-    async function advanceOnce(room, local, authorized, live) {
-        if (!live() || paused.has(room.locator))
+    async function advance(room, local, authorized, running) {
+        const live = () => running() && !full;
+        if (!live())
             return unconfirmed;
         const held = replicas.get(room.locator);
-        if (held !== undefined) {
-            const refreshed = await pullRefresh(authorized, held, live);
-            if (!live())
-                return unconfirmed;
-            if (refreshed.kind === 'still-current') {
-                stale.delete(room.locator);
-                if (sourceRefusals.has(room.locator))
-                    return null;
-                if (unreadable.delete(room.locator)) {
-                    scopedRefusals.delete(room.locator);
-                    list(room, true);
-                    emitRooms();
-                }
-                return null;
-            }
-            if (refreshed.kind === 'advanced') {
-                const landing = { kind: 'refreshed', base: refreshed.base };
-                if (!(await publish(local, room, refreshed.record, landing, live))) {
-                    const now = replicas.get(room.locator)?.record.roomVersion;
-                    const reached = now !== undefined &&
-                        options.adapter.reached(room.locator, now, refreshed.record.roomVersion);
-                    return reached ? null : advance(room, local, authorized, live);
-                }
-                await retainModel(local, room, 'collection', modelOf(room.locator));
-                return null;
-            }
-            if (refreshed.kind !== 'beyond-horizon')
+        if (held !== undefined && options.adapter.roomStream !== undefined) {
+            stale.delete(room.locator);
+            name(room.locator);
+            return null;
+        }
+        const refresh = reads.refresh;
+        if (held !== undefined && refresh !== undefined) {
+            const refreshed = await ahead((hold) => refreshedRoom(room, local, authorized, held, live, hold, refresh));
+            if (refreshed === 'behind')
+                return advance(room, local, authorized, live);
+            if (refreshed !== 'beyond-horizon')
                 return refreshed;
-            if (opened !== null) {
-                owed.add(room.locator);
-                liveQueries.recover();
-                return unconfirmed;
-            }
-            if (reloadsDue.get(room.locator) === generation)
+            if (reloadsDue.has(room.locator))
                 return unconfirmed;
+            replaced([room.locator]);
         }
+        const from = standingOf(room.locator);
         const bootstrapped = await pullBootstrap(authorized, room, local, live);
+        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)
+            ? null
+            : advance(room, local, authorized, live);
+    }
+    async function refreshedRoom(room, local, authorized, held, live, hold, refresh) {
+        const refreshed = await pullRefresh(authorized, held, live, hold, refresh);
         if (!live())
             return unconfirmed;
-        if (bootstrapped.kind !== 'staged')
-            return bootstrapped;
-        await publish(local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed }, live);
-        return null;
+        if (refreshed.kind === 'still-current') {
+            stale.delete(room.locator);
+            if (unreadable.delete(room.locator)) {
+                scopedRefusals.delete(room.locator);
+                list(room, true);
+                emitRooms();
+            }
+            return null;
+        }
+        if (refreshed.kind === 'advanced') {
+            const landing = {
+                kind: 'refreshed',
+                from: refreshed.from,
+                remodelled: refreshed.remodelled,
+            };
+            if (!(await publish(local, room, refreshed.record, landing, live))) {
+                const now = replicas.get(room.locator)?.record.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));
+            return null;
+        }
+        return refreshed.kind === 'beyond-horizon' ? 'beyond-horizon' : refreshed;
     }
     async function withhold(withheld, room, local, progress) {
-        if (withheld.kind === 'unconfirmed')
+        if (withheld.kind === 'unconfirmed' || isFenced(room.locator))
             return;
-        if (withheld.kind === 'refused')
-            stale.delete(room.locator);
-        else
-            stale.add(room.locator);
+        stale.add(room.locator);
         if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
             const reset = withheld.kind === 'retryable-refusal' ? withheld.reset : undefined;
             repairable.set(room.locator, reset);
@@ -3022,30 +3426,10 @@ export function composeRuntime(options) {
             list(room, false);
             emitRooms();
         }
-        else if (withheld.kind === 'refused') {
-            refusedSource(room, withheld);
-        }
         else if (withheld.kind === 'revoked-authorization') {
             await refuse('revoked-authorization');
         }
     }
-    function refusedSource(room, { refusal }) {
-        sourceRefusals.set(room.locator, {
-            code: refusal.rule,
-            retryable: false,
-            fields: {
-                file: refusal.file,
-                ...(refusal.location === undefined ? {} : { location: refusal.location }),
-                ...(refusal.referrers === undefined ? {} : { referrers: refusal.referrers }),
-            },
-        });
-        declarationRefusals.delete(room.locator);
-        unreadable.add(room.locator);
-        list(room, false);
-        emitRooms();
-        moveTo({ ...status, ...attention() });
-        journal.record(`source refused ${room.locator} ${refusal.rule} ${refusal.file}`);
-    }
     function leaving(batch, result) {
         if (result.kind === 'expired')
             return { batch, returned: returnedBy('expired') };
@@ -3067,8 +3451,8 @@ export function composeRuntime(options) {
     function settling(acceptance) {
         return acceptance !== null && 'apply' in acceptance;
     }
-    function refusalOf(acceptance) {
-        return settling(acceptance) ? (acceptance.refused ?? null) : acceptance;
+    function failureOf(acceptance) {
+        return settling(acceptance) ? null : acceptance;
     }
     async function acceptance(room, local, submitted, accepted) {
         if (!continuing())
@@ -3081,7 +3465,8 @@ export function composeRuntime(options) {
         logAccepted(room.locator, submitted, accepted);
         let record = current.record;
         let changes;
-        if (!options.adapter.reached(room.locator, held, accepted.roomVersion)) {
+        if (!options.adapter.reached(room.locator, held, accepted.roomVersion) &&
+            !older(room.locator, accepted.roomVersion)) {
             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));
@@ -3091,34 +3476,6 @@ export function composeRuntime(options) {
                     ? accepted.roomVersion
                     : held,
             };
-            const overrides = new Map([
-                ...back.set.map((entry) => [entry.path, entry]),
-                ...back.removed.map((path) => [path, null]),
-            ]);
-            const refused = await validatedRoom(local, record, 'confirmed', { record: current.record, changed: [...overrides.keys()] }, overrides);
-            if (refused !== null) {
-                const key = pendingKey(room.locator, submitted.id);
-                return {
-                    locator: room.locator,
-                    left: [],
-                    commit: {
-                        rooms: [],
-                        writes: [
-                            {
-                                locator: room.locator,
-                                accepted: [{ id: submitted.id, roomVersion: accepted.roomVersion }],
-                            },
-                        ],
-                    },
-                    refused,
-                    apply() {
-                        const state = pendings.get(key);
-                        if (state !== undefined && !fences.has(room.locator))
-                            pendings.set(key, { ...state, accepted: accepted.roomVersion });
-                        return changeSet(room.locator, { queue: true });
-                    },
-                };
-            }
             changes = back;
         }
         const settled = await settlement(local, room.locator, current, record, current.queue.filter((batch) => batch.id !== submitted.id), { room: true, ...(changes === undefined ? {} : { changes }) });
@@ -3126,10 +3483,9 @@ export function composeRuntime(options) {
             ...settled,
             apply(answer) {
                 const set = settled.apply(answer);
+                showing(room.locator, accepted.roomVersion);
                 pendings.delete(pendingKey(room.locator, submitted.id));
                 unreadable.delete(room.locator);
-                sourceRefusals.delete(room.locator);
-                declarationRefusals.delete(room.locator);
                 list(room, true);
                 return set;
             },
@@ -3147,13 +3503,9 @@ export function composeRuntime(options) {
         const failed = await exclusive(async () => {
             const adopting = await acceptance(room, local, submitted, accepted);
             await adoptedTogether(local, [adopting]);
-            return refusalOf(adopting);
+            return failureOf(adopting);
         });
-        if (failed === null)
-            return true;
-        if (failed.kind === 'refused' && continuing())
-            refusedSource(room, failed);
-        return false;
+        return failed === null;
     }
     async function adoptedMove(room, partner, local, submitted, accepted) {
         const other = discovered.get(partner);
@@ -3167,18 +3519,10 @@ export function composeRuntime(options) {
                     ...accepted.destination,
                 });
             await adoptedTogether(local, [left, arrived]);
-            const refusedArrival = refusalOf(arrived);
-            if (other !== undefined && refusedArrival?.kind === 'refused' && continuing()) {
-                refusedSource(other, refusedArrival);
-            }
-            return refusalOf(left);
+            return failureOf(left);
         });
         submitLater(partner);
-        if (failed === null)
-            return true;
-        if (failed.kind === 'refused' && continuing())
-            refusedSource(room, failed);
-        return false;
+        return failed === null;
     }
     function queueIn(locator) {
         return replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? [];
@@ -3297,12 +3641,10 @@ export function composeRuntime(options) {
     async function submitRoom(room, local, authorized, progress, signal) {
         while (continuing() && authorization !== undefined && !signal.aborted) {
             const replica = replicas.get(room.locator);
-            const head = replica?.queue[0];
+            const head = replica?.queue.find((batch) => !landedAhead.has(pendingKey(room.locator, batch.id)));
             if (replica === undefined || head === undefined)
                 return 'done';
             const state = pendings.get(pendingKey(room.locator, head.id));
-            if (state?.accepted !== undefined)
-                return 'done';
             const partner = partnerOf(head, room.locator);
             if (partner !== null && !leavingIn(head, room.locator)) {
                 submitLater(partner);
@@ -3416,12 +3758,12 @@ export function composeRuntime(options) {
                 }
                 if (result.kind === 'expired') {
                     await exclusive(() => mark(local, room.locator, head, { state: 'waiting' }, partner !== null && lost));
-                    const there = other === undefined ? null : await advance(other, local, authorized, continuing);
+                    const there = other === undefined ? null : await advanced(other, local, authorized);
                     if (other !== undefined && there !== null) {
                         await withhold(there, other, local, progress);
                         return 'done';
                     }
-                    const withheld = await advance(room, local, authorized, continuing);
+                    const withheld = await advanced(room, local, authorized);
                     if (withheld !== null) {
                         await withhold(withheld, room, local, progress);
                         return 'done';
@@ -3443,8 +3785,8 @@ export function composeRuntime(options) {
             if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
                 const left = leaving(head, result);
                 const refreshed = async () => ({
-                    there: other === undefined ? null : await advance(other, local, authorized, continuing),
-                    here: await advance(room, local, authorized, continuing),
+                    there: other === undefined ? null : await advanced(other, local, authorized),
+                    here: await advanced(room, local, authorized),
                 });
                 const judged = result.kind === 'conflicted' && other !== undefined ? await refreshed() : null;
                 if (judged !== null && (judged.there !== null || judged.here !== null)) {
@@ -3468,6 +3810,13 @@ export function composeRuntime(options) {
                         (await landedWhole(room.locator, head, confirmedLayer))) ||
                         (result.kind === 'conflicted' &&
                             (await landedWhole(room.locator, head, confirmedLayer, result.affected)));
+                    if (held &&
+                        result.kind === 'conflicted' &&
+                        partner === null &&
+                        !landed(head, confirmedLayer)) {
+                        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] }));
                     await unpair(local);
                     moveTo({ ...status, ...attention() });
@@ -3515,6 +3864,7 @@ export function composeRuntime(options) {
                             locator: room.locator,
                             key: before.record.key,
                             roots: before.record.typedSelection?.roots ?? [],
+                            composed: composedOf(composed(before.record)),
                             overlay: { set: [], cleared: [...before.overlaid] },
                         },
                     ]),
@@ -3523,8 +3873,10 @@ export function composeRuntime(options) {
             for (const { room, before, queue } of held) {
                 const { locator } = room;
                 lastFenced.set(locator, ++fencings);
-                for (const batch of queue)
+                for (const batch of queue) {
                     pendings.delete(pendingKey(locator, batch.id));
+                    landedAhead.delete(pendingKey(locator, batch.id));
+                }
                 queuesWithoutReplica.delete(locator);
                 if (before !== undefined) {
                     replicas.set(locator, {
@@ -3547,39 +3899,61 @@ export function composeRuntime(options) {
             if (signal.aborted)
                 return;
             const progress = { complete: true, reachable: true };
-            await roomTask(room.locator, async (live) => {
-                await Promise.race([
-                    reload(room, local, progress, () => live() && !signal.aborted),
-                    abandonedOn(signal),
-                ]);
-            });
+            await roomTask(room.locator, (live) => reload(room, local, progress, live));
             if (signal.aborted)
                 return;
             await rest(progress);
         }
     }
     function awaitingAnswer(locator) {
+        answering.get(locator)?.release();
         let release = () => { };
-        const awaited = new Promise((resolve) => {
+        const answered = new Promise((resolve) => {
             release = resolve;
         });
-        answering.set(locator, { generation, answered: awaited });
+        const awaited = { answered, release };
+        answering.set(locator, awaited);
         return () => {
-            if (answering.get(locator)?.answered === awaited)
+            if (answering.get(locator) === awaited)
                 answering.delete(locator);
             release();
         };
     }
-    async function retainModel(local, room, attached, next) {
-        const key = modelKey(room.locator, attached);
-        const previous = modelOf(room.locator, attached);
-        const heldBefore = replicas.get(room.locator)?.record;
-        if (JSON.stringify(previous) === JSON.stringify(next) &&
-            (heldBefore === undefined ||
-                (JSON.stringify(heldBefore.operations) === JSON.stringify(room.operations) &&
-                    JSON.stringify(heldBefore.replica) === JSON.stringify(room.replica) &&
-                    JSON.stringify(heldBefore.typedSelection) ===
-                        JSON.stringify(room.typedSelection ?? null))))
+    function declaredAsHeld(room) {
+        const held = replicas.get(room.locator)?.record;
+        return (held === undefined ||
+            (JSON.stringify(held.operations) === JSON.stringify(room.operations) &&
+                JSON.stringify(held.replica) === JSON.stringify(room.replica) &&
+                JSON.stringify(held.typedSelection) === JSON.stringify(room.typedSelection ?? null)));
+    }
+    async function keepNaming(local, room) {
+        const held = replicas.get(room.locator)?.record;
+        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)
+                return;
+            const record = { ...replica.record, name: room.name, handle: room.handle };
+            await local.commit({
+                rooms: [
+                    {
+                        locator: room.locator,
+                        key: record.key,
+                        record: storedRecord(record),
+                        composed: composedOf(composed(record)),
+                    },
+                ],
+            });
+            replicas.set(room.locator, { ...replica, record });
+        });
+    }
+    async function retainModel(local, room, next) {
+        const key = room.locator;
+        const previous = modelOf(room.locator);
+        if (JSON.stringify(previous) === JSON.stringify(next) && declaredAsHeld(room))
             return;
         if (next.status === 'unavailable') {
             invalidModels.add(key);
@@ -3591,26 +3965,15 @@ export function composeRuntime(options) {
             const held = replicas.get(room.locator);
             let changed = null;
             if (held !== undefined) {
-                const declared = {
+                const record = {
                     ...held.record,
+                    name: room.name,
+                    handle: room.handle,
                     operations: room.operations,
                     replica: room.replica,
                     typedSelection: room.typedSelection ?? null,
-                    ...(attached === 'collection' ? { model: next } : { selectionModel: next }),
+                    model: next,
                 };
-                let read = 'staged';
-                if (!sameMembership(declared, held.record)) {
-                    const verdict = await validatedCollection(walkOf(local, held.record.key, 'confirmed'), lookupOf(local, held.record.key, 'confirmed'), compositionOf(declared));
-                    read =
-                        verdict.verdict !== 'refuse'
-                            ? 'staged'
-                            : verdict.rule === 'model-unavailable'
-                                ? 'deferred'
-                                : { kind: 'refused', refusal: verdict };
-                }
-                const record = read === 'staged'
-                    ? declared
-                    : { ...declared, typedSelection: held.record.typedSelection };
                 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);
@@ -3621,41 +3984,33 @@ export function composeRuntime(options) {
                             key: record.key,
                             record: storedRecord(record),
                             roots: record.typedSelection?.roots ?? [],
-                            composition: compositionOf(record),
+                            composed: composedOf(composed(record)),
                             overlay: diff.overlay,
                         },
                     ],
                 });
-                recomposed(room.locator, held.record, record);
-                const { count } = committedRoom(room.locator, record, answer);
-                replicas.set(room.locator, { ...held, record, overlaid: diff.touched, count });
+                const { count, indexed } = committedRoom(room.locator, answer);
+                replicas.set(room.locator, { ...held, record, overlaid: diff.touched, count, indexed });
                 changed = changeSet(room.locator, {
                     documents: answer.changed[room.locator] ?? [],
                     room: true,
                 });
-                if (read === 'staged' || read === 'deferred') {
-                    if (declarationRefusals.delete(room.locator)) {
-                        sourceRefusals.delete(room.locator);
-                        unreadable.delete(room.locator);
-                    }
-                }
-                else {
-                    refusedSource(room, read);
-                    declarationRefusals.add(room.locator);
-                }
-            }
-            models.set(key, next);
-            if (next.status === 'current') {
-                liveModels.set(key, JSON.stringify(next.snapshot));
-                invalidModels.delete(key);
             }
-            list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
+            heldModel(room, next);
             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}`);
@@ -3669,14 +4024,14 @@ export function composeRuntime(options) {
         });
         let scopedAway = room;
         if (result.scope === 'model')
-            await retainModel(local, room, 'collection', {
+            await retainModel(local, room, {
                 status: 'unavailable',
                 reason: 'not-readable',
             });
         else if (result.scope !== 'operation') {
             unreadable.add(room.locator);
             scopedAway = { ...room, replica: { ...room.replica, admission: 'unavailable' } };
-            await retainModel(local, scopedAway, 'collection', modelOf(room.locator));
+            await retainModel(local, scopedAway, modelOf(room.locator));
         }
         if (!continuing())
             return;
@@ -3684,6 +4039,17 @@ export function composeRuntime(options) {
         emitRooms();
         journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
     }
+    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)
+            return;
+        if (!socketOpen || !handed || record.replica.selection !== room.replica.selection)
+            return;
+        naming += 1;
+        stream.hold([{ locator, roomVersion: record.roomVersion }]);
+    }
     function heldRooms(listed) {
         return listed.flatMap((room) => {
             const record = replicas.get(room.locator)?.record;
@@ -3701,14 +4067,19 @@ export function composeRuntime(options) {
             return outcome?.status === 'fulfilled' && outcome.value;
         });
         if (attempt === 'opened') {
+            naming += 1;
             options.adapter.roomStream?.hold(heldRooms(ready));
             handed = true;
         }
-        discovering?.release();
-        const loaded = await Promise.allSettled(ready
-            .filter((room) => attempt === 'unstreamed' || !replicas.has(room.locator))
-            .map((room) => roomTask(room.locator, (held) => loadRoom(room, local, progress, held))));
-        const failed = [...prepared, ...loaded].find((room) => room.status === 'rejected');
+        for (const room of ready) {
+            if (attempt !== 'unstreamed' && replicas.has(room.locator)) {
+                if (attempt === 'authorized')
+                    name(room.locator);
+                continue;
+            }
+            void roomTask(room.locator, (live) => loadRoom(room, local, progress, live)).then(() => rest(progress));
+        }
+        const failed = prepared.find((room) => room.status === 'rejected');
         if (failed !== undefined)
             throw failed.reason;
     }
@@ -3726,27 +4097,31 @@ export function composeRuntime(options) {
             return false;
         }
         if (prior !== undefined)
-            await retainModel(local, room, 'collection', modelOf(room.locator));
+            await retainModel(local, room, modelOf(room.locator));
+        if (prior !== undefined)
+            await keepNaming(local, room);
         if (discoveryPaused || authorization === undefined)
             return false;
         return room.replica.admission === 'admitted';
     }
     async function caughtUp(room, local, progress, live) {
-        if (authorization === undefined || !live() || !behind(room))
+        if (options.adapter.roomStream !== undefined || authorization === undefined)
+            return;
+        if (!live() || !behind(room))
             return;
         const withheld = await advance(room, local, authorization, live);
         if (withheld !== null)
             await withhold(withheld, room, local, progress);
     }
     function revoked(locator) {
-        return ['collection', 'typed-selection'].some((attached) => {
-            const model = modelOf(locator, attached);
-            return model.status === 'unavailable' && model.reason === 'revoked';
-        });
+        const model = modelOf(locator);
+        return model.status === 'unavailable' && model.reason === 'revoked';
     }
     async function loadRoom(room, local, progress, live) {
         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;
@@ -3764,21 +4139,53 @@ 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);
-            if (!live())
-                return;
             if (bootstrapped.kind !== 'staged') {
-                await withhold(bootstrapped, room, local, progress);
+                if (live())
+                    await withhold(bootstrapped, room, local, progress);
                 return;
             }
-            await publish(local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed }, live);
+            await publish(local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
             await caughtUp(room, local, progress, live);
         }
         finally {
             caughtUpTo(room.locator);
         }
     }
-    async function discoverRooms(local, progress, attempt, live, scope) {
+    async function asked(authorized) {
+        try {
+            return (await options.adapter.discover?.(authorized)) ?? { kind: 'transport-uncertainty' };
+        }
+        catch {
+            return { kind: 'transport-uncertainty' };
+        }
+    }
+    function malformed(listed) {
+        for (const room of listed) {
+            if (room.operations === undefined ||
+                !['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) ||
+                !['locked', 'open'].includes(room.replica.offline)) {
+                return `invalid model or replica declaration ${room.locator}`;
+            }
+            if (!declaredSelection(room))
+                return `invalid typed selection declaration ${room.locator}`;
+        }
+        return null;
+    }
+    async function signIn(local, signedIn) {
+        if (JSON.stringify(signedIn) === JSON.stringify(member))
+            return;
+        await local.fact('member', signedIn);
+        member = signedIn;
+        emitMember();
+    }
+    async function discoverRooms(local, progress, attempt, live, found) {
         if (closed || authorization === undefined) {
             notifyReady();
             return;
@@ -3786,13 +4193,9 @@ export function composeRuntime(options) {
         moveTo(transferring(status));
         discoveries += 1;
         const started = discoveries;
-        let result;
-        try {
-            result = await options.adapter.discover(authorization, scope);
-        }
-        catch {
-            result = { kind: 'transport-uncertainty' };
-        }
+        const result = found ?? (await asked(authorization));
+        if (result.kind === 'discovery')
+            roomsNamed = true;
         if (!live()) {
             progress.complete = false;
             notifyReady();
@@ -3800,12 +4203,7 @@ export function composeRuntime(options) {
         }
         journal.record(`connection discover ${result.kind}`);
         if (result.kind === 'transport-uncertainty') {
-            for (const room of rooms.values()) {
-                await retainModel(local, room, 'collection', cached(modelOf(room.locator)));
-                if (room.typedSelection !== null) {
-                    await retainModel(local, room, 'typed-selection', cached(modelOf(room.locator, 'typed-selection')));
-                }
-            }
+            await cachedModels(local);
             progress.reachable = false;
             progress.complete = false;
             notifyReady();
@@ -3826,26 +4224,12 @@ export function composeRuntime(options) {
             notifyReady();
             return;
         }
-        for (const room of result.rooms) {
-            if (room.operations === undefined ||
-                !['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) ||
-                !['locked', 'open'].includes(room.replica.offline)) {
-                journal.record(`invalid model or replica declaration ${room.locator}`);
-                await refuse('missing-required-guarantee');
-                notifyReady();
-                return;
-            }
-            if (!declaredSelection(room)) {
-                journal.record(`invalid typed selection declaration ${room.locator}`);
-                await refuse('missing-required-guarantee');
-                notifyReady();
-                return;
-            }
+        const invalid = malformed(result.rooms);
+        if (invalid !== null) {
+            journal.record(invalid);
+            await refuse('missing-required-guarantee');
+            notifyReady();
+            return;
         }
         if (refusal !== null) {
             refusal = null;
@@ -3861,13 +4245,8 @@ export function composeRuntime(options) {
             await local.fact('providerLimits', limits);
             await local.fact('capabilities', capabilities);
         }
-        const signedIn = result.member ?? null;
-        if (JSON.stringify(signedIn) !== JSON.stringify(member)) {
-            await local.fact('member', signedIn);
-            member = signedIn;
-            emitMember();
-        }
-        await synchronize(await applyDiscovery(result.rooms, started, result.covered), local, progress, attempt, live);
+        await signIn(local, result.member ?? null);
+        await synchronize(await applyDiscovery(result.rooms, started), local, progress, attempt, live);
     }
     async function ensureAuthorization() {
         if (authorization !== undefined)
@@ -3882,23 +4261,45 @@ export function composeRuntime(options) {
         }
     }
     async function admittedRead(work) {
-        if (roomReads.generation !== generation) {
-            roomReads = { generation, free: ROOM_READS, waiting: [] };
+        while (roomReads.free === 0) {
+            await new Promise((admit) => roomReads.waiting.push(admit));
         }
-        const reads = roomReads;
-        while (reads.free === 0)
-            await new Promise((admit) => reads.waiting.push(admit));
-        reads.free -= 1;
+        roomReads.free -= 1;
         try {
             await work();
         }
         finally {
-            reads.free += 1;
-            reads.waiting.shift()?.();
+            roomReads.free += 1;
+            roomReads.waiting.shift()?.();
         }
     }
+    function inRoom(locator, work) {
+        roomWork += 1;
+        const ran = (roomLanes.get(locator) ?? Promise.resolve()).then(async () => {
+            try {
+                return await work(continuing);
+            }
+            finally {
+                roomWork -= 1;
+            }
+        });
+        const chain = ran.then(() => undefined, () => undefined);
+        roomLanes.set(locator, chain);
+        working.add(chain);
+        void chain.finally(() => {
+            working.delete(chain);
+            if (roomLanes.get(locator) === chain)
+                roomLanes.delete(locator);
+        });
+        return ran;
+    }
     function roomTask(locator, work) {
-        return task(roomLane(locator), (live) => admittedRead(() => work(live)));
+        if (stopping)
+            return Promise.resolve();
+        return inRoom(locator, (live) => admittedRead(() => work(live))).catch(() => undefined);
+    }
+    function advanced(room, local, authorized) {
+        return inRoom(room.locator, (live) => advance(room, local, authorized, live));
     }
     function task(lane, work) {
         if (stopping)
@@ -3914,23 +4315,19 @@ export function composeRuntime(options) {
         void run.finally(() => working.delete(run));
         return run;
     }
-    function sync(attempt) {
+    function sync(attempt, found) {
         return task(OPENING_LANE, async (live) => {
             if (!live()) {
-                notifyReady();
+                readyFromStore();
                 return;
             }
             const progress = { complete: true, reachable: true };
-            const gate = discover();
-            if (attempt === 'opened')
-                opened = generation;
-            underway = attempt === 'opened' ? { generation, progress } : null;
+            underway = attempt === 'opened' ? progress : null;
             if (attempt === 'opened')
                 streamed = progress;
             complete = false;
             recorded = false;
             moveTo(transferring(status));
-            handed = false;
             try {
                 const local = await openLocal();
                 if (!live())
@@ -3938,7 +4335,7 @@ export function composeRuntime(options) {
                 await ensureAuthorization();
                 if (!live())
                     return;
-                await discoverRooms(local, progress, attempt, live);
+                await discoverRooms(local, progress, attempt, live, found);
             }
             catch {
                 progress.complete = false;
@@ -3946,7 +4343,6 @@ export function composeRuntime(options) {
                     progress.reachable = false;
             }
             finally {
-                gate.release();
                 notifyReady();
             }
             if (!live())
@@ -3958,35 +4354,59 @@ export function composeRuntime(options) {
             if (handed || closed || progress.reachable)
                 return;
             underway = null;
-            opened = null;
-            journal.record('connection reopen');
             await rest(progress, live);
-            options.adapter.roomStream?.reopen();
         });
     }
-    function rediscover(scope) {
+    function resynchronize() {
         return task(OPENING_LANE, async (live) => {
-            if (!live() || !socketOpen)
+            if (!live() || !announced)
                 return;
             const progress = { complete: true, reachable: true };
-            const gate = discover();
             moveTo(transferring(status));
             try {
                 const local = await openLocal();
                 if (!live())
                     return;
-                await ensureAuthorization();
+                await synchronize([...discovered.values()], local, progress, 'unstreamed', live);
+            }
+            catch {
+                progress.complete = false;
+            }
+            if (live())
+                await finishOpening(progress, live);
+        });
+    }
+    function countAuthorityChange() {
+        authorityChanges += 1;
+        for (const listener of authorityChangeListeners)
+            listener(authorityChanges);
+    }
+    function changeAuthority(change) {
+        return task(OPENING_LANE, async (live) => {
+            if (!live() || !announced)
+                return;
+            countAuthorityChange();
+            const progress = { complete: true, reachable: true };
+            moveTo(transferring(status));
+            try {
+                const local = await openLocal();
                 if (!live())
                     return;
-                await discoverRooms(local, progress, 'authorized', live, scope);
+                const invalid = malformed(change.rooms);
+                if (invalid !== null) {
+                    journal.record(invalid);
+                    await refuse('missing-required-guarantee');
+                    return;
+                }
+                if (change.member !== undefined)
+                    await signIn(local, change.member);
+                discoveries += 1;
+                const listed = await applyDiscovery(change.rooms, discoveries, change.left);
+                await synchronize(listed, local, progress, 'authorized', live);
             }
             catch {
                 progress.complete = false;
             }
-            finally {
-                gate.release();
-                notifyReady();
-            }
             if (!live())
                 return;
             if (!progress.complete)
@@ -3994,14 +4414,17 @@ export function composeRuntime(options) {
             await rest(progress, live);
         });
     }
-    function closedSocket(revoked, lost) {
-        const opened = socketOpen;
+    function closedSocket(revoked, lost, authorityChanged) {
+        notifyReady();
+        const opened = announced;
         socketOpen = false;
+        announced = false;
+        missedChange ||= authorityChanged;
+        handed = false;
+        naming = 0;
         connectionLost();
-        if (lost) {
-            reads.lost();
+        if (lost)
             conversations.lost();
-        }
         if (revoked) {
             void refuse('revoked-authorization');
             return;
@@ -4012,18 +4435,32 @@ export function composeRuntime(options) {
         moveTo({
             ...status,
             state: status.state === 'synced' ? 'syncing' : status.state,
-            providerUnreachable: status.providerUnreachable || !opened,
+            providerUnreachable: status.providerUnreachable || (!opened && lost),
+        });
+        void closing(opened);
+    }
+    function closing(opened) {
+        return task(OPENING_LANE, async (live) => {
+            if (!live())
+                return;
+            const local = await openLocal();
+            if (!opened && !socketOpen)
+                await cachedModels(local);
+            await rest(null, live);
         });
     }
-    function applyOpening(expired) {
-        const progress = underway?.generation === generation ? underway.progress : null;
+    function cachedModels(local) {
+        return settleModels([...rooms.values()].map((room) => discovered.get(room.locator) ?? room), 'cached', local);
+    }
+    function caughtUpRooms(expired) {
+        const progress = underway;
+        underway = null;
+        naming = Math.max(0, naming - 1);
         const cycle = progress ?? { complete: true, reachable: true };
-        if (opened === generation)
-            opened = null;
+        replaced(expired);
         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())
                 return;
             if (progress === null) {
@@ -4031,24 +4468,14 @@ export function composeRuntime(options) {
                 await rest(cycle, live);
                 return;
             }
-            await roomsCarried([...expired, ...reloading]);
-            if (!live())
-                return;
             try {
                 const local = await openLocal();
-                const reloaded = await replacing;
+                await replacing;
                 if (progress.reachable) {
-                    for (const room of discovered.values()) {
-                        if (replicas.has(room.locator) &&
-                            !expired.includes(room.locator) &&
-                            !reloading.includes(room.locator)) {
-                            await confirmModels(room, local);
-                        }
-                    }
+                    await settleModels([...discovered.values()].filter((room) => replicas.has(room.locator) &&
+                        !expired.includes(room.locator) &&
+                        !reloading.includes(room.locator)), 'current', local);
                 }
-                const failed = reloaded.find((outcome) => outcome.status === 'rejected');
-                if (failed !== undefined)
-                    throw failed.reason;
             }
             catch {
                 progress.complete = false;
@@ -4060,11 +4487,8 @@ export function composeRuntime(options) {
     }
     function owedReloads(expired) {
         const reloading = [...discovered.values()]
-            .filter((room) => replicas.has(room.locator) &&
-            !expired.includes(room.locator) &&
-            (owed.has(room.locator) || revoked(room.locator)))
+            .filter((room) => replicas.has(room.locator) && !expired.includes(room.locator) && revoked(room.locator))
             .map((room) => room.locator);
-        owed.clear();
         for (const locator of reloading)
             catching.add(locator);
         liveQueries.recover();
@@ -4073,24 +4497,43 @@ export function composeRuntime(options) {
     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);
+            reloadsDue.add(room.locator);
         try {
             const local = await openLocal();
-            return await Promise.allSettled(reloaded.map((room) => roomTask(room.locator, (live) => reload(room, local, progress, live))));
+            for (const room of reloaded) {
+                void roomTask(room.locator, (live) => reload(room, local, progress, live)).then(() => rest(progress));
+            }
         }
         catch {
             for (const room of reloaded)
                 reloadsDue.delete(room.locator);
             progress.reachable = false;
-            return [];
         }
     }
-    async function confirmModels(room, local) {
-        for (const attached of ['collection', 'typed-selection']) {
-            const model = modelOf(room.locator, attached);
-            if (model.status === 'cached') {
-                await retainModel(local, room, attached, { ...model, status: 'current' });
+    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 () => {
+            if (!continuing())
+                return [];
+            const unchanged = held.filter((room) => owed(room) && declaredAsHeld(room));
+            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);
             }
+            if (unchanged.length > 0)
+                emitRooms();
+            return unchanged;
+        });
+        for (const room of held) {
+            if (settled.includes(room) || !owed(room))
+                continue;
+            await retainModel(local, room, { ...modelOf(room.locator), status });
         }
     }
     function submitLater(locator) {
@@ -4135,14 +4578,10 @@ export function composeRuntime(options) {
         try {
             const local = await openLocal();
             await roomTask(locator, async (live) => {
-                const current = () => live() && !signal.aborted;
-                if (!current() || authorization === undefined)
+                if (!live() || authorization === undefined)
                     return;
-                const withheld = await Promise.race([
-                    advance(room, local, authorization, current),
-                    abandonedOn(signal),
-                ]);
-                if (withheld !== null && current())
+                const withheld = await advance(room, local, authorization, live);
+                if (withheld !== null && live())
                     await withhold(withheld, room, local, progress);
             });
         }
@@ -4197,14 +4636,11 @@ export function composeRuntime(options) {
                 progress.complete = false;
                 return;
             }
-            reads.applied();
             submitAll();
             for (const locator of stale)
                 if (repairable.has(locator))
                     repairLater(locator, {});
             await conversations.reconcile();
-            if (status.providerUnreachable)
-                conversations.reconnected();
             const reading = { complete: true, reachable: true };
             await conversations.catchUp(reading);
             if (progress.reachable && reading.reachable)
@@ -4230,7 +4666,7 @@ export function composeRuntime(options) {
         if (!live())
             return;
         let lastCompleted = status.lastCompleted;
-        let synced = complete && stale.size === 0 && !pending();
+        let synced = complete && roomWork === 0 && naming === 0 && stale.size === 0 && !pending();
         if (synced && !recorded) {
             const completedAt = new Date().toISOString();
             try {
@@ -4245,74 +4681,78 @@ export function composeRuntime(options) {
             }
         }
         moveTo({
-            state: pending() ? 'pending' : synced && complete ? 'synced' : 'syncing',
+            state: pending()
+                ? 'pending'
+                : synced && complete && roomWork === 0 && naming === 0
+                    ? 'synced'
+                    : 'syncing',
             lastCompleted,
-            providerUnreachable: !progress.reachable,
+            providerUnreachable: progress === null ? status.providerUnreachable : !progress.reachable,
             ...attention(),
         });
     }
-    function discover() {
-        let release = () => { };
-        const done = new Promise((resolve) => {
-            release = resolve;
-        });
-        discovering = { generation, done, release };
-        return discovering;
-    }
-    function applyRoom(locator, roomVersion) {
-        announced.set(locator, roomVersion);
-        return task(roomLane(locator), async (live) => {
-            if (discovering?.generation === generation)
-                await discovering.done;
-            const saving = answering.get(locator);
-            if (saving?.generation === generation)
-                await saving.answered;
-            if (!live() || authorization === undefined)
-                return;
-            const room = discovered.get(locator);
-            const held = replicas.get(locator);
-            if (room === undefined || room.replica.admission !== 'admitted')
-                return;
-            if (held !== undefined &&
-                (held.record.replica.selection !== room.replica.selection ||
-                    options.adapter.reached(locator, held.record.roomVersion, roomVersion))) {
-                return;
-            }
-            const during = underway?.generation === generation ? underway.progress : null;
-            const progress = during ?? { complete: true, reachable: true };
-            if (during === null)
-                moveTo(transferring(status));
+    function applyRoom(change) {
+        const { locator } = change;
+        if (stopping)
+            return Promise.resolve();
+        return inRoom(locator, async (live) => {
+            await answering.get(locator)?.answered;
+            const progress = underway ?? { complete: true, reachable: true };
             try {
                 const local = await openLocal();
-                await admittedRead(async () => {
-                    if (!live() || authorization === undefined)
-                        return;
-                    const withheld = await advance(room, local, authorization, live);
-                    if (withheld !== null)
-                        await withhold(withheld, room, local, progress);
-                });
+                for (;;) {
+                    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) {
+                        return null;
+                    }
+                    const at = held.record.roomVersion;
+                    if (options.adapter.reached(locator, at, change.roomVersion))
+                        return progress;
+                    if (!options.adapter.reached(locator, at, change.from)) {
+                        name(locator);
+                        return progress;
+                    }
+                    if (underway === null)
+                        moveTo(transferring(status));
+                    const writing = () => live() && !full;
+                    let outlined = false;
+                    const refreshed = await ahead((hold) => pullRefresh(authorization ?? {}, held, writing, hold, async () => {
+                        const page = await change.read();
+                        const paths = Object.keys(page.outlines ?? {});
+                        outlined = paths.length > 0;
+                        await local.remember(locator, held.record.key, paths);
+                        return page;
+                    }));
+                    if (refreshed.kind !== 'advanced')
+                        return progress;
+                    const landing = {
+                        kind: 'refreshed',
+                        from: refreshed.from,
+                        remodelled: refreshed.remodelled,
+                    };
+                    if (await publish(local, room, refreshed.record, landing, writing)) {
+                        stale.delete(locator);
+                        await retainModel(local, room, modelOf(locator));
+                        if (outlined)
+                            void heldAgain(locator);
+                        return progress;
+                    }
+                }
             }
             catch {
+                if (!stale.has(locator))
+                    name(locator);
                 stale.add(locator);
+                return progress;
             }
-            finally {
-                if (during === null)
-                    await rest(progress, live);
-            }
-        });
+        }).then((progress) => rest(progress), () => undefined);
     }
-    function roomsCarried(replacing) {
-        const replaced = new Set(replacing.map(roomLane));
-        return Promise.all([...lanes]
-            .filter(([lane, held]) => lane !== OPENING_LANE && !replaced.has(lane) && held.generation === generation)
-            .map(([, held]) => held.chain));
-    }
-    const receipts = {
-        heads: async () => (await openLocal()).receivedHeads(),
-        parts: async (key, count) => (await openLocal()).receivedParts(key, count),
-        keep: async (key, head, part) => (await openLocal()).keepReceived(key, head, part),
-        drop: async (keys) => (await openLocal()).dropReceived(keys),
-    };
     function observeStream() {
         const stream = options.adapter.roomStream;
         if (stream === undefined || withdrawStream !== undefined)
@@ -4322,29 +4762,35 @@ export function composeRuntime(options) {
                 return;
             if (event.kind === 'opened') {
                 socketOpen = true;
+                announced = false;
+                handed = false;
+                naming = 0;
                 connectionLive();
                 generation += 1;
-                reads.opened();
                 conversations.reopened();
                 recovery.resume();
-                void sync('opened');
+            }
+            else if (event.kind === 'discovered') {
+                if (!socketOpen)
+                    return;
+                announced = true;
+                if (missedChange) {
+                    missedChange = false;
+                    countAuthorityChange();
+                }
+                void sync('opened', event.discovery);
+                for (const locator of replicas.keys())
+                    void heldAgain(locator);
             }
             else if (event.kind === 'closed')
-                closedSocket(event.revoked, event.lost);
-            else if (event.kind === 'opening')
-                void applyOpening(event.expired);
+                closedSocket(event.revoked, event.lost, event.authorityChanged);
+            else if (event.kind === 'caught-up')
+                void caughtUpRooms(event.expired);
             else if (event.kind === 'authority-changed')
-                void rediscover(event.scope);
+                void changeAuthority(event);
             else
-                void applyRoom(event.locator, event.roomVersion);
-        }, receipts, heldRevisions);
-    }
-    async function heldRevisions(locator, paths) {
-        const held = replicas.get(locator);
-        if (held === undefined || paths.length === 0)
-            return new Map();
-        const entries = await (await openLocal()).entries(held.record.key, 'confirmed', paths);
-        return new Map(entries.flatMap(({ path, revision }) => revision === null ? [] : [[path, revision]]));
+                void applyRoom(event);
+        });
     }
     function writesHeld() {
         return serviceMode === 'write-halted' || haltedRefusal;
@@ -4414,8 +4860,9 @@ export function composeRuntime(options) {
         if (closed)
             return;
         closed = true;
-        if (rechecking !== null)
-            clearInterval(rechecking);
+        notifyDiscovered();
+        if (probing !== null)
+            clearInterval(probing);
         connectionLive();
         lockListeners.clear();
         readinessWatches.clear();
@@ -4427,11 +4874,13 @@ export function composeRuntime(options) {
         conversations.close();
         void recovery.retire();
         roomListeners.clear();
+        unlistedRooms.clear();
         refusalListeners.clear();
         storageLossListeners.clear();
         statusListeners.clear();
         serviceModeListeners.clear();
         memberListeners.clear();
+        authorityChangeListeners.clear();
         liveQueries.close();
         queueSubscriptions.clear();
         roomDraftListeners.clear();
@@ -4439,6 +4888,7 @@ export function composeRuntime(options) {
     }
     async function stop() {
         stopping = true;
+        inFlight.abort();
         await recovery.retire();
         await Promise.all(working);
         await mutations;
@@ -4452,20 +4902,20 @@ export function composeRuntime(options) {
     observeStream();
     void openLocal().then(() => {
         if (capabilities.length > 0)
-            notifyReady();
+            readyFromStore();
     }, () => {
-        notifyReady();
+        readyFromStore();
     });
     if (options.adapter.roomStream === undefined)
-        void sync('unstreamed');
+        void sync('unstreamed', null);
     function planned(input, reach) {
-        const plan = planOf(input, roomFacts(reach), planReach(reach));
+        const plan = planWithin(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) {
+    function watchPlan(plan, deliver, fail) {
         let seeded = false;
         let pending = true;
         const shown = () => {
@@ -4491,7 +4941,7 @@ export function composeRuntime(options) {
             }
             seeded = false;
             deliver(message);
-        });
+        }, fail);
         return () => {
             watchers.delete(shown);
             if (watchers.size === 0)
@@ -4499,61 +4949,59 @@ export function composeRuntime(options) {
             stop();
         };
     }
-    async function searched(input, reach, locked) {
+    async function searched(input, reach) {
         const asked = searchPlanOf(input);
-        const filter = {
-            ...filterOf(asked.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 = [...unlocking, ...('pending' in cover ? cover.pending : [])];
-            const complete = pending.length === 0 && !('pending' in cover);
-            const awaited = new Set('pending' in cover ? cover.pending.map(({ room }) => room) : []);
-            const answering = complete
-                ? filter
-                : { ...filter, rooms: reachedRooms(filter).filter((room) => !awaited.has(room)) };
-            const answered = covered(answering);
-            if ('pending' in answered)
-                continue;
-            const listed = conversations.searchable();
-            const named = reach !== null && !reach.conversations
-                ? []
-                : (asked.conversations ?? listed).filter((one) => listed.includes(one) && conversations.acquired(one));
-            const hits = await (await openLocal()).search({
-                text: asked.text,
-                limit: capped(asked.limit),
-                after: asked.after,
-                total: asked.total,
-                documents: {
-                    plan: answering,
-                    rooms: answered.rooms,
-                    beneath: asked.collection
-                        ? answered.rooms.map(({ locator, key }) => ({
-                            key,
-                            roots: replicas.get(locator)?.record.typedSelection?.roots ?? [],
-                        }))
-                        : [],
-                },
-                conversations: named,
-            });
-            if (JSON.stringify(covered(answering)) !== JSON.stringify(answered))
-                continue;
-            const coverage = {
-                rooms: answered.coverage.rooms,
-                conversations: named,
-                overlay: answered.coverage.overlay,
+        await ready;
+        const search = options.adapter.search;
+        if (search === undefined) {
+            return {
+                kind: 'undeclared',
+                code: 'action-undeclared',
+                fields: { name: 'search' },
+                retryable: false,
             };
-            return complete
-                ? { ...hits, coverage }
-                : { pending, documents: hits.documents, messages: hits.messages, coverage };
+        }
+        if (closed || refusal !== null || connectionOf() !== 'connected')
+            return OFFLINE;
+        const reached = reach === null ? null : new Set(reach.rooms);
+        const named = asked.rooms === null
+            ? reached === null
+                ? null
+                : [...reached]
+            : asked.rooms.filter((room) => reached === null || reached.has(room));
+        const rooms = named === null ? null : named.filter((room) => replicas.has(room)).sort();
+        if (rooms !== null && rooms.length === 0)
+            return { kind: 'found', documents: [] };
+        try {
+            await ensureAuthorization();
+        }
+        catch {
+            return UNCERTAIN;
+        }
+        if (closed || authorization === undefined || refusal !== null)
+            return UNCERTAIN;
+        journal.record('transfer search');
+        try {
+            const result = await search(authorization, { text: asked.text, rooms });
+            if (result.kind === 'revoked-authorization')
+                await refuse('revoked-authorization');
+            journal.record(`outcome search ${result.kind}`);
+            if (result.kind === 'rejected')
+                return result;
+            if (result.kind !== 'found')
+                return failure(result);
+            const kept = rooms === null ? null : new Set(rooms);
+            return {
+                kind: 'found',
+                documents: result.documents.filter((hit) => kept === null || kept.has(hit.room)),
+            };
+        }
+        catch {
+            journal.record('outcome search transport-uncertainty');
+            return UNCERTAIN;
         }
     }
-    const watch = (topic, input, deliver) => {
+    const watch = (topic, input, deliver, fail) => {
         if (topic === 'room-drafts') {
             const listener = { notify: deliver, ready: false };
             roomDraftListeners.add(listener);
@@ -4602,12 +5050,13 @@ export function composeRuntime(options) {
             };
         }
         if (topic === 'readiness') {
-            return watchReadiness({ target: '', code: 'stored', capacity: null, search: 'unused' }, null, deliver);
+            return watchReadiness({ target: '', code: 'stored' }, null, deliver);
         }
         if (topic === 'rooms') {
-            roomListeners.add(deliver);
-            deliver(listed());
+            unlistedRooms.add(deliver);
+            emitKnownRooms();
             return () => {
+                unlistedRooms.delete(deliver);
                 roomListeners.delete(deliver);
             };
         }
@@ -4646,6 +5095,13 @@ export function composeRuntime(options) {
                 memberListeners.delete(deliver);
             };
         }
+        if (topic === 'authority-changes') {
+            authorityChangeListeners.add(deliver);
+            deliver(authorityChanges);
+            return () => {
+                authorityChangeListeners.delete(deliver);
+            };
+        }
         if (topic === 'queue') {
             const queue = { locator: input[0], notify: deliver };
             queueSubscriptions.add(queue);
@@ -4654,24 +5110,34 @@ export function composeRuntime(options) {
                 queueSubscriptions.delete(queue);
             };
         }
-        return watchPlan(planned(input[0], null), deliver);
+        return watchPlan(planned(input[0], null), deliver, fail);
     };
     const md = {
         loaded() {
             return openLocal().then(() => undefined);
         },
         rooms() {
-            return listed();
+            if (closed)
+                return Promise.resolve([]);
+            return new Promise((settle) => {
+                const answer = (value) => {
+                    unlistedRooms.delete(answer);
+                    roomListeners.delete(answer);
+                    settle(value);
+                };
+                unlistedRooms.add(answer);
+                emitKnownRooms();
+            });
         },
         query: ((input) => rowsQuery(planned(input, null))),
-        search: (input) => searched(input, null, []),
+        search: (input) => searched(input, null),
         types(locator) {
             return {
                 collection: modelTypes(modelOf(locator)),
                 typedSelection: rooms.get(locator)?.typedSelection === undefined ||
                     rooms.get(locator)?.typedSelection === null
                     ? null
-                    : modelTypes(modelOf(locator, 'typed-selection')),
+                    : modelTypes(builtIn),
             };
         },
         roomDraft: {
@@ -4688,33 +5154,17 @@ export function composeRuntime(options) {
                 const record = roomDrafts.get(room)?.get(path);
                 return record === undefined ? null : ((await roomDraftsOf([record]))[0] ?? null);
             },
-            write(room, path, revision, input) {
-                return exclusive(async () => {
-                    const parts = readParts(input);
-                    if (path === '' || normalize(path) !== path)
-                        throw runtimeError('room-draft-malformed');
-                    const local = await openLocal();
-                    const current = roomDrafts.get(room)?.get(path);
-                    if ((current?.revision ?? null) !== revision) {
-                        return staleWrite(current === undefined ? null : ((await roomDraftsOf([current]))[0] ?? null));
-                    }
-                    const file = parts.file === undefined
-                        ? undefined
-                        : await heldFile(parts.file.blob, binaryBase(await visibleOf(room, [path]), path));
-                    const record = {
-                        locator: room,
-                        path,
-                        revision: roomDraftRevision(),
-                        parts: held(current?.parts, parts, file),
-                        returned: current?.returned ?? null,
-                    };
-                    await local.keepRoomDraft(record, parts.file === undefined || file === undefined
-                        ? []
-                        : [{ key: file.localId, blob: parts.file.blob }]);
-                    rememberRoomDraft(record);
-                    publishChangeSet(changeSet(room, { drafts: [path] }));
-                    return { outcome: 'written', roomDraft: (await roomDraftsOf([record]))[0] ?? null };
-                });
+            write(room, path, revision, input, next = roomDraftRevision()) {
+                if (typeof next !== 'string' || next === '')
+                    return Promise.reject(runtimeError('room-draft-malformed'));
+                return gathered(`room-draft\u0000${room}\u0000${path}`, { revision, input, next }, (earlier, later) => {
+                    if (later.revision !== earlier.next)
+                        return null;
+                    const parts = gatheredParts(earlier.input, later.input);
+                    return parts === null
+                        ? null
+                        : { revision: earlier.revision, input: parts, next: later.next };
+                }, (written) => writtenRoomDraft(room, path, written.revision, written.input, written.next));
             },
             discard(room, path, revision) {
                 return exclusive(async () => {
@@ -4741,13 +5191,13 @@ export function composeRuntime(options) {
                 });
             },
             write(app, value) {
-                return keepPresentation(app, () => structuredClone(value));
+                return exclusive(() => keptPresentation(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),
-                ]));
+                return gathered(`presentation\u0000${app}`, structuredClone(members), (earlier, later) => ({ ...earlier, ...later }), (edited) => keptPresentation(app, (held) => Object.fromEntries([
+                    ...Object.entries(plain(held) ? held : {}).filter(([member]) => !Object.hasOwn(edited, member)),
+                    ...Object.entries(edited).filter(([, value]) => value !== null),
+                ])));
             },
         },
         save(room, named, writtenBy) {
@@ -4766,7 +5216,8 @@ export function composeRuntime(options) {
             part: readPart,
             read: readBinaryPath,
             link: linkBinaryPath,
-            readReference: readBinaryReference,
+            show: showBinaryPath,
+            attach: attachBinary,
         },
         async call(name, input) {
             await ready;
@@ -4789,7 +5240,8 @@ export function composeRuntime(options) {
             journal.record('retry');
             unpreparable.clear();
             queueReadiness();
-            resume();
+            if (full)
+                await probed();
         },
         observe: observing(watch),
         async reauthorize() {
@@ -4803,7 +5255,7 @@ export function composeRuntime(options) {
             authorization = undefined;
             discoveryPaused = false;
             if (options.adapter.roomStream === undefined)
-                await sync('unstreamed');
+                await sync('unstreamed', null);
             else
                 await task(OPENING_LANE, ensureAuthorization);
         },
@@ -4811,7 +5263,6 @@ export function composeRuntime(options) {
     const reachable = {
         md,
         watch,
-        referrerScope: (referrer) => options.adapter.referrerScope(referrer),
         plan: planned,
         query: (plan) => rowsQuery(plan),
         watchPlan,
@@ -4821,12 +5272,12 @@ export function composeRuntime(options) {
         lockedRooms,
         watchLocks,
         located,
+        room: (locator) => listed().find((one) => one.locator === locator),
     };
     return {
         md,
         seed,
         stop,
-        lose: loseRooms,
         watch,
         persisted(answer) {
             if (answer === persistence)
@@ -4835,6 +5286,10 @@ export function composeRuntime(options) {
             journal.record(`persistence ${answer}`);
             queueReadiness();
         },
-        within: (reach, port) => narrowed(reachable, reach, port),
+        within: (reach, port) => {
+            if (full)
+                void probed();
+            return narrowed(reachable, reach, port);
+        },
     };
 }