@agentshouse/mdruntime 0.1.0-c03e7b79830dd → 0.1.0-c0bed82db8d73

package/dist/connection.js

@@ -6,7 +6,7 @@ import { filterOf, identityOf, planOf, plain, queryKey, } from './query.js';
 import { createLiveQueries } from './live.js';
 import { seededResult } from './seed.js';
 import { documentKey, roomOfKey } from './rows.js';
-import { createSearchIndex, searchPlanOf, } from './search.js';
+import { searchPlanOf } from './search.js';
 import { capped, MAXIMUM_WINDOW } from './windows.js';
 import { bootstrapRoom } from './bootstrap.js';
 import { changeSet, mergeChangeSets } from './change-set.js';
@@ -17,18 +17,17 @@ import { runtimeError } from './failure.js';
 import { createLog } from './log.js';
 import { binaryRecord } from './binary.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, binaryAnswer, binaryLinkAnswer, calledResult, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, 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 { binaryBase, changedParts, changesOf, gatheredParts, held, heldFile, joinedDraft, moveTarget, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
 import { same, saving, STARTING, transferring, } from './status.js';
-import { detectStorageLoss, nextGeneration } from './durability.js';
-import { 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';
@@ -37,15 +36,6 @@ import { openRuntimeStore, } from './store.js';
 import { changedCleanly, sameComposition, validatedCollection, } from './validation.js';
 import { unconfirmed } from './transfer.js';
 import { governs, holds, narrowed, planReach, } from './reach.js';
-function roomsAlone(plan) {
-    return (plan.reach === null &&
-        plan.root.types === null &&
-        plan.root.where === null &&
-        plan.root.pathPrefix === null &&
-        plan.paths === null &&
-        plan.hop === null &&
-        plan.backlinks === null);
-}
 function within(root, path) {
     return root === '' || beneath(root, path);
 }
@@ -63,12 +53,23 @@ const OPENING_LANE = 'opening';
 const CONVERSATION_LANE = 'conversations';
 const ROOM_READS = 256;
 const ROOM_ATTEMPTS = 16;
-const SEARCH_BATCH = 256;
 const ERASE_BATCH = 512;
 const REDERIVE_BATCH = 256;
 const WALK_BYTES = 1 << 20;
 const QUERY_BYTES = 1 << 20;
 const STAGE_BYTES = 1 << 20;
+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 PARTS_HELD = 4;
+// Bytes still arriving are reported at most this often, well inside the 2 s progress bound, so readiness is not rebuilt for every chunk the network hands over.
+const ARRIVAL_REPORT_MS = 250;
+const INSTALL_STEPS = [
+    'writing',
+    'downloading',
+    'replaying',
+    'listing',
+];
 const CLEAN_CHANGES = 2_000;
 // A Room that locks offline stays readable this long after the connection drops, so a laptop waking or changing network keeps working while a disconnected device locks soon after.
 const LOCK_GRACE_MS = 120_000;
@@ -92,10 +93,9 @@ function pendingKey(locator, 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;
-    let store;
     const fences = new Map();
     const isFenced = (locator) => fences.has(locator);
     let fencings = 0;
@@ -172,6 +172,7 @@ export function composeRuntime(options) {
     let roomReads = { generation, free: ROOM_READS, waiting: [] };
     const working = new Set();
     let mutations = Promise.resolve();
+    let gathering = null;
     const roomListeners = new Set();
     const refusalListeners = new Set();
     const storageLossListeners = new Set();
@@ -192,19 +193,39 @@ export function composeRuntime(options) {
     const serviceModeListeners = new Set();
     let member = null;
     const memberListeners = new Set();
-    const prepared = new Set();
     const unpreparedDemand = new Set();
-    const unindexable = 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 Map();
+    const arrivals = new Map();
+    let arrivalReported = 0;
+    let onScreen = options.shell.onScreen;
+    const shownWaiters = [];
+    let partsFree = PARTS_HELD;
+    const partWaiters = [];
+    let stageBytes = STAGE_FLOOR * 4;
+    let installWrites = Promise.resolve();
     const conversations = createConversationStore({
         agents: declaredAgents,
         documents: (declaration, after) => rowsQuery(planOf({
@@ -225,36 +246,13 @@ export function composeRuntime(options) {
         stream: () => options.adapter.conversations,
         publish: publishChangeSet,
         online: () => connectionOf() !== 'unreachable' && refusal === null,
+        full: () => full,
         closed: () => closed,
         unanswered: resendLater,
         expired: (operation) => pastHorizon(operation),
     });
-    const searchIndex = createSearchIndex({
-        async *room(room) {
-            const local = await openLocal();
-            for (let after = null;;) {
-                const key = replicas.get(room)?.record.key;
-                if (key === undefined)
-                    return;
-                const page = await local.searched(key, room, after, SEARCH_BATCH, null);
-                yield page.documents;
-                if (page.next === null)
-                    return;
-                after = page.next;
-            }
-        },
-        async documents(room, paths) {
-            const key = replicas.get(room)?.record.key;
-            if (key === undefined || paths.length === 0)
-                return [];
-            return (await (await openLocal()).searched(key, room, null, paths.length, paths)).documents;
-        },
-    });
-    const roomsToIndex = new Set();
-    const conversationsToIndex = new Set();
-    let indexing = false;
     const journal = createLog();
-    const keptFiles = openedFiles(options.database, isFenced);
+    const keptFiles = openedFiles(database, isFenced);
     let notifyReady = () => { };
     const ready = new Promise((resolve) => {
         notifyReady = resolve;
@@ -334,14 +332,38 @@ 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);
+        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: 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)
@@ -532,23 +554,26 @@ export function composeRuntime(options) {
     }
     function applyChangeSet(set) {
         liveQueries.touched(set);
-        searchIndex.changed(set);
     }
     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 now = replicas.get(locator);
+            if (now?.record.key !== key)
                 continue;
             if (!done)
                 continue;
-            prepared.add(locator);
+            replicas.set(locator, { ...now, indexed: true });
             publishChangeSet(changeSet(locator, { documents: null }));
             liveQueries.recover();
             queueReadiness();
@@ -556,11 +581,11 @@ export function composeRuntime(options) {
         }
     }
     function unprepared() {
-        return [...unpreparedDemand, ...replicas.keys()].find((locator) => !prepared.has(locator) && !unindexable.has(locator));
+        return [...unpreparedDemand, ...replicas.keys()].find((locator) => !indexed(locator) && !unpreparable.has(locator));
     }
-    function unbuilt(locator, error) {
-        unindexable.add(locator);
-        journal.record(`index failed ${locator} ${error instanceof Error ? error.name : 'unknown'}`);
+    function unpreparedBy(locator, error) {
+        unpreparable.add(locator);
+        journal.record(`preparation failed ${locator} ${error instanceof Error ? error.name : 'unknown'}`);
         queueReadiness();
     }
     function prepare(locators = []) {
@@ -576,7 +601,7 @@ export function composeRuntime(options) {
                     if (closed)
                         return;
                     unpreparedDemand.delete(waiting);
-                    await prepareReplica(waiting).catch((error) => unbuilt(waiting, error));
+                    await prepareReplica(waiting).catch((error) => unpreparedBy(waiting, error));
                 }
             }
             finally {
@@ -617,7 +642,7 @@ 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;
             }
@@ -650,7 +675,7 @@ export function composeRuntime(options) {
             return { listed: true, rooms: named.filter((room) => rooms.has(room)) };
         return { listed: named.every((room) => replicas.has(room)), rooms: named };
     }
-    function roomState(locator, search) {
+    function roomState(locator) {
         if (sourceRefusals.has(locator))
             return 'refused';
         const listedRoom = discovered.get(locator);
@@ -661,27 +686,17 @@ export function composeRuntime(options) {
             return 'unadmitted';
         if (!replicas.has(locator))
             return 'acquiring';
-        if (!prepared.has(locator))
+        if (!indexed(locator))
             return 'preparing';
-        if (search && !searchIndex.rooms().has(locator))
-            return 'indexing';
         return 'complete';
     }
-    function conversationCoverage(reach, search) {
+    function conversationCoverage(reach) {
         const declared = reach === null || reach.conversations;
         if (!declared || options.adapter.conversations === undefined || declaredAgents() === undefined)
             return 'undeclared';
         if (!conversations.known() || !conversations.current())
             return 'acquiring';
-        if (!search)
-            return 'complete';
-        const unindexed = conversations
-            .searchable()
-            .filter((one) => conversations.acquired(one) && !searchIndex.conversations().has(one));
-        if (unindexed.length === 0)
-            return 'complete';
-        index([], unindexed);
-        return 'indexing';
+        return 'complete';
     }
     function connectionOf() {
         if (socketOpen)
@@ -701,6 +716,7 @@ export function composeRuntime(options) {
             return [
                 {
                     room,
+                    name: discovered.get(room)?.name ?? room,
                     file: typeof file === 'string' ? file : '',
                     rule: held.code,
                     location: typeof location === 'string' ? location : null,
@@ -708,34 +724,73 @@ export function composeRuntime(options) {
             ];
         });
     }
+    function installationOf(coverage) {
+        const rooms = { done: 0, total: 0 };
+        const parts = { done: 0, total: 0 };
+        const bytes = { done: 0, total: 0 };
+        const received = { done: 0, total: 0 };
+        const steps = new Set();
+        let waiting = false;
+        for (const { room, state } of coverage) {
+            if (state === 'unadmitted')
+                continue;
+            rooms.total += 1;
+            if (state === 'complete')
+                rooms.done += 1;
+            const transfer = transfers.get(room);
+            const held = installs.get(room);
+            const inventory = transfer?.inventory ?? replicas.get(room)?.record.inventory ?? null;
+            if (inventory !== null) {
+                const done = transfer?.done ?? inventory;
+                const share = held?.share ?? null;
+                parts.total += inventory.parts;
+                bytes.total += inventory.bytes;
+                parts.done += done.parts;
+                bytes.done += done.bytes;
+                if (share !== null && share.entries > 0) {
+                    bytes.done += Math.floor((share.bytes * share.written) / share.entries);
+                }
+                received.total += inventory.bytes;
+                received.done += done.bytes + (share?.bytes ?? 0);
+                for (const arrived of arrivals.get(room)?.values() ?? [])
+                    received.done += arrived;
+            }
+            const installing = held !== undefined && state !== 'complete';
+            if (installing)
+                steps.add(held.step);
+            waiting ||= installing || state === 'acquiring';
+        }
+        return {
+            step: INSTALL_STEPS.find((step) => steps.has(step)) ?? null,
+            paused: waiting && !onScreen ? 'hidden' : null,
+            rooms,
+            parts,
+            bytes,
+            received,
+        };
+    }
     function readinessFor(port, reach) {
         const required = requiredRooms(reach);
         const search = port.search === 'required';
-        const coverage = required.rooms.map((room) => ({ room, state: roomState(room, search) }));
-        const building = (state) => coverage
-            .filter((room) => room.state === state && !unindexable.has(room.room))
+        const coverage = required.rooms.map((room) => ({ room, state: roomState(room) }));
+        const preparing = coverage
+            .filter((room) => room.state === 'preparing' && !unpreparable.has(room.room))
             .map(({ room }) => room);
-        const preparing = building('preparing');
         if (preparing.length > 0)
             prepare(preparing);
-        const indexing = building('indexing');
-        if (indexing.length > 0)
-            index(indexing, []);
         return readinessOf({
             code: port.code,
             coverage: {
                 listed: required.listed,
                 rooms: coverage,
-                conversations: conversationCoverage(reach, search),
+                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,
+            space: full ? 'full' : port.space,
+            installation: installationOf(coverage),
             refused: refusedIn(required.rooms),
             lost: storageLoss !== null,
             established: targets[port.target]?.established === true,
@@ -744,6 +799,7 @@ export function composeRuntime(options) {
     function establish(name) {
         targets = { ...targets, [name]: { established: true } };
         queueReadiness();
+        probeEachMinute();
         void durably((local) => local.fact('targets', targets)).catch(() => {
             journal.record(`target record failed ${name}`);
         });
@@ -781,87 +837,51 @@ 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 ?? '-'}`);
+    function filled() {
+        if (full || closed)
+            return;
+        full = true;
+        journal.record('space full');
         queueReadiness();
-        if (rechecking !== null)
+        probeEachMinute();
+    }
+    function installedTarget() {
+        return Object.values(targets).some((target) => target.established);
+    }
+    function probeEachMinute() {
+        if (!full || probing !== null || closed || !installedTarget())
             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();
+        // 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 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 probed() {
+        testing ??= database.ask({ kind: 'space.probe' }).then(() => {
+            testing = null;
+            spaceFreed();
+            return true;
+        }, () => {
+            testing = null;
+            return false;
+        });
+        return testing;
     }
-    function resume() {
-        if (rechecking !== null)
-            clearInterval(rechecking);
-        rechecking = null;
-        if (paused.size === 0 && capacity === null)
+    function spaceFreed() {
+        if (!full)
             return;
-        paused.clear();
-        capacity = null;
-        journal.record('capacity resumed');
+        full = false;
+        if (probing !== null)
+            clearInterval(probing);
+        probing = null;
+        unpreparable.clear();
+        journal.record('space freed');
         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;
-    }
-    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)
-            return true;
-        pause(locator, { cause: 'insufficient-space', needed, available });
-        return false;
-    }
-    async function exceededOn(locator, bytes) {
-        const available = await estimated().catch(() => null);
-        pause(locator, { cause: 'storage-exceeded', needed: bytes, available });
-    }
     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));
@@ -982,81 +1002,6 @@ export function composeRuntime(options) {
         const held = answered.cover;
         return { ...answered.rows, coverage: held.coverage };
     }
-    async function everyRow(plan) {
-        const window = { ...plan, limit: MAXIMUM_WINDOW, after: null, total: false };
-        const first = await rowsQuery(window);
-        if ('pending' in first || first.next === undefined)
-            return first;
-        const documents = 'documents' in first ? [...first.documents] : [];
-        const groups = 'groups' in first ? [...first.groups] : [];
-        for (let next = first.next; next !== undefined;) {
-            const values = JSON.parse(next);
-            const page = await rowsQuery({
-                ...window,
-                after: { text: next, values: values.length === 0 ? null : values },
-            });
-            if ('pending' in page)
-                return page;
-            if ('documents' in page)
-                documents.push(...page.documents);
-            else
-                groups.push(...page.groups);
-            if (JSON.stringify(page.coverage) !== JSON.stringify(first.coverage))
-                return everyRow(plan);
-            next = page.next;
-        }
-        return 'documents' in first
-            ? { documents, coverage: first.coverage }
-            : { groups, coverage: first.coverage };
-    }
-    async function indexConversation(conversation) {
-        searchIndex.indexMessages(conversation, [], false);
-        let after = null;
-        for (;;) {
-            const batch = await durably((local) => local.messagesAfter(conversation, after));
-            if (closed)
-                return;
-            searchIndex.indexMessages(conversation, batch.map(({ identity, text }) => ({ conversation, identity, text })), batch.length === 0);
-            if (batch.length === 0)
-                return;
-            after = batch[batch.length - 1].identity;
-        }
-    }
-    function indexNext() {
-        const room = [...roomsToIndex].find((locator) => !searchIndex.rooms().has(locator) && !unindexable.has(locator));
-        if (room !== undefined) {
-            roomsToIndex.delete(room);
-            return () => prepared.has(room)
-                ? searchIndex.indexRoom(room).catch((error) => unbuilt(room, error))
-                : undefined;
-        }
-        const conversation = [...conversationsToIndex].find((one) => !searchIndex.conversations().has(one));
-        if (conversation === undefined)
-            return null;
-        conversationsToIndex.delete(conversation);
-        return () => indexConversation(conversation);
-    }
-    function index(rooms, named) {
-        for (const room of rooms)
-            roomsToIndex.add(room);
-        for (const conversation of named)
-            conversationsToIndex.add(conversation);
-        if (indexing)
-            return;
-        indexing = true;
-        void (async () => {
-            try {
-                for (let unit = indexNext(); unit !== null && !closed; unit = indexNext()) {
-                    await yielded();
-                    await unit();
-                    queueReadiness();
-                }
-            }
-            finally {
-                indexing = false;
-            }
-        })().catch(() => { });
-    }
     function publishChangeSet(set) {
         applyChangeSet(set);
         if (set.rooms.length > 0 ||
@@ -1086,9 +1031,10 @@ export function composeRuntime(options) {
                         held,
                         record: { ...held.record, model: revoked, selectionModel: 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,
@@ -1114,8 +1060,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);
@@ -1255,9 +1201,7 @@ export function composeRuntime(options) {
             unreadable.delete(locator);
             stale.delete(locator);
             repairable.delete(locator);
-            unindexable.delete(locator);
-            paused.delete(locator);
-            prepared.delete(locator);
+            unpreparable.delete(locator);
             scopedRefusals.delete(locator);
             sourceRefusals.delete(locator);
             declarationRefusals.delete(locator);
@@ -1271,7 +1215,6 @@ export function composeRuntime(options) {
         }
         if (fresh.length === 0)
             return fresh;
-        searchIndex.forget(fresh);
         publishChangeSet(mergeChangeSets(removed.map(({ locator, drafts }) => changeSet(locator, { documents: null, room: true, queue: true, drafts }))));
         liveQueries.recover();
         moveTo({ ...status, ...attention() });
@@ -1365,7 +1308,6 @@ export function composeRuntime(options) {
             }
         }
         replicas.clear();
-        prepared.clear();
         queuesWithoutReplica.clear();
         for (const [locator, queue] of queuedBatches) {
             if (!held.rooms.has(locator))
@@ -1383,9 +1325,8 @@ export function composeRuntime(options) {
                 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);
@@ -1431,8 +1372,7 @@ export function composeRuntime(options) {
     async function open() {
         if (closed)
             throw new Error('runtime closed');
-        const opened = await openRuntimeStore(isFenced, options.database);
-        store = opened;
+        const opened = openRuntimeStore(isFenced, database);
         const interrupted = await opened.fences();
         for (const locator of interrupted) {
             fences.set(locator, { at: discoveries, erased: false });
@@ -1478,10 +1418,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));
@@ -1563,23 +1522,11 @@ 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)));
@@ -1729,14 +1676,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, {
@@ -1782,7 +1729,7 @@ export function composeRuntime(options) {
         };
     }
     function publish(local, room, record, landing, live) {
-        return exclusive(async () => {
+        const landed = exclusive(async () => {
             if (!live()) {
                 caughtUpTo(room.locator);
                 return true;
@@ -1819,9 +1766,8 @@ export function composeRuntime(options) {
                     });
             }
             catch (error) {
-                if (!exceeded(error))
+                if (!refusedForSpace(error))
                     throw error;
-                await exceededOn(room.locator, null);
                 caughtUpTo(room.locator);
                 return true;
             }
@@ -1833,7 +1779,7 @@ export function composeRuntime(options) {
             for (const batch of accepted)
                 pendings.delete(pendingKey(room.locator, batch.id));
             stale.delete(room.locator);
-            unindexable.delete(room.locator);
+            unpreparable.delete(room.locator);
             if (unreadable.delete(room.locator))
                 scopedRefusals.delete(room.locator);
             sourceRefusals.delete(room.locator);
@@ -1848,6 +1794,7 @@ export function composeRuntime(options) {
             }
             return true;
         });
+        return landing.kind === 'refreshed' ? landed : landed.finally(() => installed(room.locator));
     }
     async function savedRoom(locator) {
         const local = await openLocal();
@@ -2244,6 +2191,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);
@@ -2522,11 +2471,6 @@ 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;
@@ -2539,16 +2483,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)
@@ -2595,7 +2536,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;
@@ -2609,7 +2550,6 @@ export function composeRuntime(options) {
             locator,
             path: confirmedAt,
             revision: record.revision,
-            fileRef: record.fileRef,
         };
     }
     async function readBinaryPath(locator, path, revision) {
@@ -2640,18 +2580,11 @@ export function composeRuntime(options) {
             return absentBinary(path);
         return transferBinary(asked, (held) => options.adapter.link(held, asked), binaryLinkAnswer);
     }
-    async function readBinaryReference(reference) {
-        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 });
-    }
     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' });
+        const freed = await database.ask({ kind: 'opened.clean' });
         return freed + ((await options.shell.cleanUp?.()) ?? 0);
     }
     function declaredAgents() {
@@ -2878,41 +2811,108 @@ export function composeRuntime(options) {
             return unreadableRoom(texts, walk, named);
         return null;
     }
-    function refreshingOf(local, key, liveness) {
+    function refreshingOf(local, key, liveness, replaying = null) {
+        const write = replaying === null ? exclusive : installWrite;
         return {
+            async turn() {
+                if (replaying === null)
+                    return;
+                installing(replaying, 'replaying');
+                await screened();
+            },
             prior: async (paths) => new Map((await local.entries(key, 'refreshed', paths)).map((entry) => [entry.path, entry])),
             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;;) {
+                    if (replaying !== null)
+                        await screened();
+                    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(() => local.refresh(key, 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 > stageBytes && end > from)
+                break;
             spent += size;
+            end += 1;
+        }
+        return end;
+    }
+    async function timed(work) {
+        const started = performance.now();
+        const done = await work();
+        const spent = performance.now() - started;
+        if (spent < STAGE_AIM_MS / 2)
+            stageBytes = Math.min(STAGE_BYTES, Math.round(stageBytes * 1.5));
+        else if (spent > STAGE_AIM_MS * 2) {
+            stageBytes = Math.max(STAGE_FLOOR, Math.round(stageBytes / 1.5));
         }
-        return batches;
+        return done;
+    }
+    function installWrite(work) {
+        const next = installWrites.then(() => exclusive(work), () => exclusive(work));
+        installWrites = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    function screened() {
+        if (onScreen || closed)
+            return Promise.resolve();
+        queueReadiness();
+        return new Promise((resolve) => shownWaiters.push(resolve));
+    }
+    async function heldPart() {
+        while (partsFree === 0)
+            await new Promise((admit) => partWaiters.push(admit));
+        partsFree -= 1;
+        return freed();
+    }
+    function freed() {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            partsFree += 1;
+            partWaiters.shift()?.();
+        };
+    }
+    function installing(locator, step, share = null) {
+        installs.set(locator, { step, share });
+        queueReadiness();
+    }
+    function installed(locator) {
+        if (installs.delete(locator))
+            queueReadiness();
+    }
+    function screen(value) {
+        if (value === onScreen)
+            return;
+        onScreen = value;
+        journal.record(`installation ${value ? 'shown' : 'hidden'}`);
+        queueReadiness();
+        if (!value)
+            return;
+        for (const resolve of shownWaiters.splice(0))
+            resolve();
     }
     async function pullRefresh(authorized, held, liveness) {
         if (!liveness())
@@ -2940,6 +2940,8 @@ export function composeRuntime(options) {
             return { kind: 'advanced', record: result.record, base };
         }
         catch (error) {
+            if (refusedForSpace(error))
+                return unconfirmed;
             journal.record(`transfer refresh ${record.locator} transport-uncertainty`);
             throw error;
         }
@@ -2966,38 +2968,105 @@ export function composeRuntime(options) {
     function staging(local, liveness) {
         return {
             held: (locator) => transfers.get(locator) ?? null,
-            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);
+            async turn(locator, step) {
+                installing(locator, step);
+                for (;;) {
+                    await screened();
+                    const release = step === 'downloading' ? await heldPart() : () => { };
+                    if (onScreen || closed)
+                        return release;
+                    release();
+                }
+            },
+            spare() {
+                if (!onScreen || closed || partsFree === 0)
+                    return null;
+                partsFree -= 1;
+                return freed();
+            },
+            arriving(locator) {
+                let ended = false;
+                return {
+                    at(token, bytes) {
+                        if (ended)
+                            return;
+                        const held = arrivals.get(locator) ?? new Map();
+                        arrivals.set(locator, held.set(token, bytes));
+                        const now = performance.now();
+                        if (now - arrivalReported < ARRIVAL_REPORT_MS)
+                            return;
+                        arrivalReported = now;
+                        queueReadiness();
+                    },
+                    end() {
+                        ended = true;
+                        if (arrivals.delete(locator))
+                            queueReadiness();
+                    },
+                };
+            },
+            received: (locator, token) => local.transferPart(locator, token),
+            keep: (locator, token, received) => installWrite(async () => {
+                if (liveness())
+                    await local.keepPart(locator, token, received);
+            }),
+            announced(locator) {
+                const later = announced.get(locator);
+                return later === undefined ? [] : [later];
+            },
+            async stage(record, page, composition, received) {
+                const { locator } = record;
+                const whole = received?.byteLength ?? 0;
+                const from = record.writing?.written ?? 0;
+                const token = record.writing?.token ?? null;
+                const entries = page.entries.length;
+                let held = record;
+                if (token !== null)
+                    arrivals.get(locator)?.delete(token);
+                installing(locator, 'writing', { written: from, entries, bytes: whole });
+                for (let written = from;;) {
+                    await screened();
+                    if (!liveness())
+                        return null;
+                    const end = batchEnd(page.entries, written);
+                    const last = end === entries;
+                    const next = last
+                        ? {
+                            ...held,
+                            writing: null,
+                            done: {
+                                parts: held.done.parts + (received === null ? 0 : 1),
+                                bytes: held.done.bytes + whole,
+                            },
                         }
-                        catch (error) {
-                            if (!exceeded(error))
-                                throw error;
-                            await exceededOn(record.locator, bytes);
+                        : { ...held, writing: { token, written: end } };
+                    const key = await installWrite(async () => {
+                        if (!liveness())
                             return null;
-                        }
+                        return timed(() => local.stage(next, composition, {
+                            entries: page.entries.slice(written, end),
+                            folders: last ? page.folders : [],
+                        }, last && received !== null && token !== null ? token : undefined));
                     });
-                    if (staged === null)
+                    if (key === null)
                         return null;
-                    key = staged;
+                    const arrived = !transfers.has(locator);
+                    held = { ...next, key };
+                    transfers.set(locator, held);
+                    if (arrived)
+                        liveQueries.recover();
+                    if (last) {
+                        installing(locator, held.pageToken === null ? 'replaying' : 'downloading');
+                        liveQueries.recover();
+                        return held;
+                    }
+                    installing(locator, 'writing', { written: end, entries, bytes: whole });
+                    written = end;
                 }
-                transfers.set(record.locator, { ...record, key });
-                liveQueries.recover();
-                return key;
             },
-            async refreshing(key) {
+            async refreshing(locator, key) {
                 await exclusive(() => local.unrefresh(key));
-                return refreshingOf(local, key, liveness);
+                return refreshingOf(local, key, liveness, locator);
             },
             abandon: (locator) => exclusive(async () => {
                 if (!liveness())
@@ -3043,13 +3112,18 @@ export function composeRuntime(options) {
             }, (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') {
                 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 {
@@ -3073,8 +3147,9 @@ export function composeRuntime(options) {
         }
         return advanceOnce(room, local, authorized, live);
     }
-    async function advanceOnce(room, local, authorized, live) {
-        if (!live() || paused.has(room.locator))
+    async function advanceOnce(room, local, authorized, running) {
+        const live = () => running() && !full;
+        if (!live())
             return unconfirmed;
         const held = replicas.get(room.locator);
         if (held !== undefined) {
@@ -3114,12 +3189,11 @@ export function composeRuntime(options) {
                 return unconfirmed;
         }
         const bootstrapped = await pullBootstrap(authorized, room, local, live);
-        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 (bootstrapped.kind === 'staged') {
+            await publish(local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed }, live);
+            return live() ? null : unconfirmed;
+        }
+        return live() ? bootstrapped : unconfirmed;
     }
     async function withhold(withheld, room, local, progress) {
         if (withheld.kind === 'unconfirmed')
@@ -3753,9 +3827,8 @@ export function composeRuntime(options) {
                         },
                     ],
                 });
-                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,
@@ -3892,10 +3965,9 @@ export function composeRuntime(options) {
             if (!live() || authorization === undefined)
                 return;
             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);
@@ -4541,8 +4613,10 @@ export function composeRuntime(options) {
         if (closed)
             return;
         closed = true;
-        if (rechecking !== null)
-            clearInterval(rechecking);
+        if (probing !== null)
+            clearInterval(probing);
+        for (const resolve of shownWaiters.splice(0))
+            resolve();
         connectionLive();
         lockListeners.clear();
         readinessWatches.clear();
@@ -4553,10 +4627,6 @@ export function composeRuntime(options) {
         withdrawServiceMode?.();
         conversations.close();
         void recovery.retire();
-        store?.close();
-        void opening?.then((opened) => {
-            opened.close();
-        }, () => { });
         roomListeners.clear();
         refusalListeners.clear();
         storageLossListeners.clear();
@@ -4632,9 +4702,8 @@ export function composeRuntime(options) {
     }
     async function searched(input, reach, locked) {
         const asked = searchPlanOf(input);
-        const plan = { ...asked, limit: capped(asked.limit) };
         const filter = {
-            ...filterOf(plan.documents ?? {}, roomFacts(reach), planReach(reach)),
+            ...filterOf(asked.documents ?? {}, roomFacts(reach), planReach(reach)),
             locked,
         };
         const unlocking = (filter.rooms ?? [])
@@ -4643,65 +4712,41 @@ export function composeRuntime(options) {
         for (;;) {
             const cover = covered(filter);
             awaitPreparation(cover);
-            const pending = [
-                ...unlocking,
-                ...('pending' in cover ? cover.pending : []),
-            ];
-            const awaited = new Set('pending' in cover ? cover.pending.map(({ room }) => room) : []);
-            const held = covered({
-                ...filter,
-                rooms: reachedRooms(filter).filter((room) => !awaited.has(room)),
-            });
-            const covering = 'pending' in held ? [] : held.coverage.rooms;
-            const unindexed = covering
-                .filter(({ room }) => !searchIndex.rooms().has(room))
-                .map(({ room }) => room);
-            for (const room of unindexed)
-                pending.push({ room, awaits: 'index' });
-            const listed = conversations.searchable();
-            const named = reach !== null && !reach.conversations
-                ? []
-                : (plan.conversations ?? listed).filter((one) => listed.includes(one) && conversations.acquired(one));
-            const waiting = named.filter((one) => !searchIndex.conversations().has(one));
-            for (const conversation of waiting)
-                pending.push({ conversation, awaits: 'index' });
-            if (unindexed.length > 0 || waiting.length > 0)
-                index(unindexed, waiting);
+            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: covering
-                        .filter(({ room }) => searchIndex.rooms().has(room))
-                        .map(({ room }) => room),
-                };
+                : { ...filter, rooms: reachedRooms(filter).filter((room) => !awaited.has(room)) };
             const answered = covered(answering);
             if ('pending' in answered)
                 continue;
-            const searchedConversations = named.filter((one) => searchIndex.conversations().has(one));
-            const seen = searchIndex.changes();
-            await searchIndex.caughtUp();
-            const selected = roomsAlone(answering) ? null : await everyRow(answering);
-            if (selected !== null && 'pending' in selected)
-                continue;
-            if (searchIndex.changes() !== seen ||
-                JSON.stringify(covered(answering)) !== JSON.stringify(answered))
+            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 hits = searchIndex.search(plan, selected === null ? null : selected.documents, searchedConversations, answering.rooms !== null
-                ? new Set(answering.rooms)
-                : locked.length === 0
-                    ? null
-                    : new Set(reachedRooms(answering)), plan.collection
-                ? new Map(answered.coverage.rooms.map(({ room }) => [
-                    room,
-                    replicas.get(room)?.record.typedSelection?.roots ?? [],
-                ]))
-                : null);
             const coverage = {
                 rooms: answered.coverage.rooms,
-                conversations: searchedConversations,
-                index: searchIndex.generation(),
+                conversations: named,
                 overlay: answered.coverage.overlay,
             };
             return complete
@@ -4758,7 +4803,7 @@ export function composeRuntime(options) {
             };
         }
         if (topic === 'readiness') {
-            return watchReadiness({ target: '', code: 'stored', capacity: null, search: 'unused' }, null, deliver);
+            return watchReadiness({ target: '', code: 'stored', space: null, search: 'unused' }, null, deliver);
         }
         if (topic === 'rooms') {
             roomListeners.add(deliver);
@@ -4844,33 +4889,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 () => {
@@ -4897,13 +4926,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) {
@@ -4922,7 +4951,6 @@ export function composeRuntime(options) {
             part: readPart,
             read: readBinaryPath,
             link: linkBinaryPath,
-            readReference: readBinaryReference,
         },
         async call(name, input) {
             await ready;
@@ -4943,9 +4971,10 @@ export function composeRuntime(options) {
         },
         async retry() {
             journal.record('retry');
-            unindexable.clear();
+            unpreparable.clear();
             queueReadiness();
-            resume();
+            if (full)
+                await probed();
         },
         observe: observing(watch),
         async reauthorize() {
@@ -4967,7 +4996,6 @@ export function composeRuntime(options) {
     const reachable = {
         md,
         watch,
-        referrerScope: (referrer) => options.adapter.referrerScope(referrer),
         plan: planned,
         query: (plan) => rowsQuery(plan),
         watchPlan,
@@ -4991,6 +5019,11 @@ export function composeRuntime(options) {
             journal.record(`persistence ${answer}`);
             queueReadiness();
         },
-        within: (reach, port) => narrowed(reachable, reach, port),
+        shown: screen,
+        within: (reach, port) => {
+            if (full)
+                void probed();
+            return narrowed(reachable, reach, port);
+        },
     };
 }