@agentshouse/mdruntime 0.1.0-ca14c49c06d90 → 0.1.0-ca4dc698bd0c4

package/dist/connection.js

@@ -6,22 +6,27 @@ import { createReadSide } from './read-side.js';
 import { markdownPath, roomOfKey } from './rows.js';
 import { createSearchIndex, searchPlanOf, } from './search.js';
 import { bootstrapRoom } from './bootstrap.js';
-import { changeSet, mergeChangeSets } from './change-set.js';
+import { changeSet, entering, mergeChangeSets } from './change-set.js';
 import { createConversationStore, } from './conversation.js';
 import { queuedFile } from './change.js';
-import { validRoot } from './collection.js';
+import { indexReferrers, referencesIndexed, validRoot, } from './collection.js';
 import { runtimeError } from './failure.js';
 import { createLog } from './log.js';
 import { binaryRecord } from './binary.js';
 import { absentBinary, binaryAnswer, calledResult, failure, historyAnswer, undeclared, UNCERTAIN, } from './outcome.js';
+import { createRecovery } from './recovery.js';
 import { refreshRoom } from './refresh.js';
 import { buildBatch, joined, limitedIn, requeued } from './save.js';
 import { applyReturned, compositionOf, confirmedOf, landed, readReclassified, replicaOf, sameMembership, withdrawals, } from './replica.js';
 import { binaryBase, changedParts, changesOf, held, heldFile, joinedDraft, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
 import { same, saving, STARTING, transferring, } from './status.js';
 import { detectStorageLoss, nextGeneration } from './durability.js';
+import { demanded, narrower, WHOLE_DEMAND, wider } from './acquisition.js';
+import { readinessOf, SETTLED_ROOMS, } from './readiness.js';
 import { FencedMap } from './fence.js';
-import { roomDraftRevision } from './identity.js';
+import { tally } from './shared.js';
+import { inChunks, ROW_WEIGHT, yielded } from './turn.js';
+import { identityTime, roomDraftRevision } from './identity.js';
 import { beneath, normalize } from './paths.js';
 import { openRuntimeStore, } from './store.js';
 import { unconfirmed } from './transfer.js';
@@ -42,6 +47,29 @@ function declaredSelection(room) {
 const OPENING_LANE = 'opening';
 const CONVERSATION_LANE = 'conversations';
 const ROOM_READS = 256;
+const ROOM_ATTEMPTS = 16;
+const outside = new Map();
+function outsideOf(roots) {
+    const key = JSON.stringify(roots);
+    const held = outside.get(key);
+    if (held !== undefined)
+        return held;
+    const counted = (path) => (roots.some((root) => beneath(root, path)) ? 0 : 1);
+    const made = {
+        documents: (path) => (markdownPath(path) ? counted(path) : 0),
+        binaries: counted,
+    };
+    outside.set(key, made);
+    return made;
+}
+function abandonedOn(signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted)
+            resolve(null);
+        else
+            signal.addEventListener('abort', () => resolve(null), { once: true });
+    });
+}
 function roomLane(locator) {
     return `room ${locator}`;
 }
@@ -98,7 +126,6 @@ export function composeRuntime(options) {
     let status = STARTING;
     let shown = STARTING;
     let discoveryPaused = false;
-    let resetTimer;
     let closed = false;
     let stopping = false;
     let withdrawStream;
@@ -106,7 +133,10 @@ export function composeRuntime(options) {
     let underway = null;
     let streamed = null;
     let handed = false;
-    const submitting = new Map();
+    const recovery = (options.recovery ?? createRecovery()).scope(ROOM_ATTEMPTS);
+    const repairing = new Set();
+    const repairable = new Map();
+    let outcomeRetention = null;
     const answering = new Map();
     let complete = false;
     let recorded = false;
@@ -136,25 +166,41 @@ export function composeRuntime(options) {
     const serviceModeListeners = new Set();
     let member = null;
     const memberListeners = new Set();
-    const materialized = new Set();
-    let everyRoom = false;
+    const prepared = new Set();
+    const projecting = new Set();
+    const unpreparedDemand = new Set();
+    const unindexable = new Set();
+    let preparing = false;
+    let demand = WHOLE_DEMAND;
+    let narrowing = null;
+    let targets = {};
+    let persistence = options.shell.persistence;
+    let capacity = null;
+    const paused = new Set();
+    let rechecking = null;
+    const readinessWatches = new Set();
+    let readinessQueued = false;
+    const catching = new Set();
     const transfers = new FencedMap(isFenced);
     const conversations = createConversationStore({
         agents: declaredAgents,
-        documents: (locator) => rowsQuery(planOf({ rooms: [locator], select: 'all' }, roomFacts())),
+        documents: ({ locator }) => rowsQuery(planOf({ rooms: [locator], select: { fields: 'all' } }, roomFacts())),
         call: (name, input) => invokeAction(name, input),
         durably,
         stream: () => options.adapter.conversations,
         publish: publishChangeSet,
         online: () => !status.providerUnreachable && refusal === null,
         closed: () => closed,
+        unanswered: resendLater,
+        expired: (operation) => pastHorizon(operation),
     });
     const searchIndex = createSearchIndex({
-        documents: () => readSide.documents(),
+        room: (room) => readSide.room(room),
         document: (room, path) => readSide.document(room, path),
-        messages: () => conversations.messages(),
-        message: (conversation, identity) => conversations.message(conversation, identity),
     });
+    const roomsToIndex = new Set();
+    const conversationsToIndex = new Set();
+    let indexing = false;
     const journal = createLog();
     let notifyReady = () => { };
     const ready = new Promise((resolve) => {
@@ -233,9 +279,16 @@ 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;
@@ -254,11 +307,9 @@ export function composeRuntime(options) {
         if (replica === undefined)
             return 0;
         const roots = replica.confirmed.record.typedSelection?.roots ?? [];
-        const paths = [
-            ...Object.keys(replica.visible.documents).filter(markdownPath),
-            ...Object.keys(replica.visible.binaries),
-        ];
-        return paths.filter((path) => !roots.some((root) => beneath(root, path))).length;
+        const weighed = outsideOf(roots);
+        return (tally(replica.visible.documents, weighed.documents) +
+            tally(replica.visible.binaries, weighed.binaries));
     }
     function listed() {
         return structuredClone([...rooms.values()].map((room) => {
@@ -285,15 +336,19 @@ export function composeRuntime(options) {
         return { listed: roomsListed, rooms: held };
     }
     function emitRooms() {
+        readSide.recover();
+        queueReadiness();
         const value = listed();
         for (const listener of roomListeners)
             listener(value);
     }
     function emitRefusal() {
+        queueReadiness();
         for (const listener of refusalListeners)
             listener(refusal);
     }
     function emitStorageLoss() {
+        queueReadiness();
         for (const listener of storageLossListeners)
             listener(storageLoss);
     }
@@ -310,7 +365,8 @@ export function composeRuntime(options) {
     function show() {
         if (closed)
             return;
-        const next = status.state === 'synced' && !conversations.current()
+        queueReadiness();
+        const next = status.state === 'synced' && demand.conversations && !conversations.current()
             ? { ...status, state: 'syncing' }
             : status;
         if (same(shown, next))
@@ -339,42 +395,481 @@ export function composeRuntime(options) {
         }
     }
     function applyChangeSet(set) {
-        const held = everyRoom
-            ? set
-            : { ...set, documents: set.documents.filter(({ locator }) => materialized.has(locator)) };
+        const held = {
+            ...set,
+            documents: set.documents.filter(({ locator }) => prepared.has(locator) || projecting.has(locator)),
+        };
         readSide.apply(held);
         searchIndex.changed(held);
     }
-    function materialize(locators) {
-        if (everyRoom)
+    async function referenced(locator) {
+        for (;;) {
+            const record = replicas.get(locator)?.confirmed.record;
+            if (record === undefined || closed)
+                return;
+            const held = { text: record.documents, binaries: record.binaries };
+            const composition = compositionOf(record);
+            if (referencesIndexed(held, composition))
+                return;
+            await indexReferrers(held, composition);
+        }
+    }
+    async function prepareReplica(locator) {
+        await referenced(locator);
+        const replica = replicas.get(locator);
+        if (replica === undefined || closed || prepared.has(locator))
             return;
-        if (locators === null)
-            everyRoom = true;
-        const sets = [];
-        for (const locator of locators ?? [...replicas.keys()]) {
-            if (materialized.has(locator))
-                continue;
-            materialized.add(locator);
-            const replica = replicas.get(locator);
-            if (replica !== undefined)
-                sets.push(changeSet(locator, null, replica));
+        const visible = replica.visible;
+        const paths = [
+            ...new Set([...Object.keys(visible.documents), ...Object.keys(visible.binaries)]),
+        ];
+        const entered = [];
+        projecting.add(locator);
+        try {
+            await inChunks(paths, (path) => ROW_WEIGHT + (visible.documents[path]?.length ?? 0), (chunk) => {
+                const current = replicas.get(locator);
+                if (current === undefined || closed)
+                    return;
+                const set = entering(locator, current, chunk);
+                readSide.apply(set);
+                entered.push(set);
+            });
+            if (!replicas.has(locator) || closed)
+                return;
+            prepared.add(locator);
+        }
+        finally {
+            projecting.delete(locator);
         }
-        if (sets.length === 0)
+        conversations.changed(mergeChangeSets(entered));
+        readSide.recover();
+        queueReadiness();
+    }
+    function unprepared() {
+        return [...unpreparedDemand, ...replicas.keys()].find((locator) => !prepared.has(locator) && !unindexable.has(locator));
+    }
+    function unbuilt(locator, error) {
+        unindexable.add(locator);
+        journal.record(`index failed ${locator} ${error instanceof Error ? error.name : 'unknown'}`);
+        queueReadiness();
+    }
+    function prepare(locators = []) {
+        for (const locator of locators)
+            unpreparedDemand.add(locator);
+        if (preparing)
             return;
-        const set = mergeChangeSets(sets);
-        readSide.apply(set);
-        searchIndex.changed(set);
+        preparing = true;
+        void (async () => {
+            try {
+                for (let waiting = unprepared(); waiting !== undefined; waiting = unprepared()) {
+                    await yielded();
+                    if (closed)
+                        return;
+                    unpreparedDemand.delete(waiting);
+                    await prepareReplica(waiting).catch((error) => unbuilt(waiting, error));
+                }
+            }
+            finally {
+                preparing = false;
+            }
+        })();
     }
     function reachedRooms(plan) {
-        if (plan.rooms !== null)
-            return plan.rooms;
-        if (plan.reach === null)
+        const reach = plan.reach;
+        const reached = reach === null ? null : new Set([...reach.rooms, ...reach.documents.map(roomOfKey)]);
+        const named = plan.rooms ??
+            (reached === null
+                ? [...new Set([...rooms.keys(), ...replicas.keys(), ...queuesWithoutReplica.keys()])]
+                : [...reached]);
+        return [...new Set(named)].filter((locator) => reached === null || reached.has(locator)).sort();
+    }
+    function awaited(locator) {
+        return rooms.has(locator) || !roomsListed;
+    }
+    function covered(plan) {
+        const locators = reachedRooms(plan);
+        if (locators.length === 0 && plan.rooms === null && plan.reach === null && !roomsListed) {
+            return { pending: [] };
+        }
+        const pending = [];
+        const coverage = [];
+        const overlay = [];
+        for (const locator of locators) {
+            const replica = replicas.get(locator);
+            if (replica === undefined) {
+                if (awaited(locator))
+                    pending.push({ room: locator, awaits: 'acquisition' });
+                continue;
+            }
+            if (!prepared.has(locator)) {
+                pending.push({ room: locator, awaits: 'preparation' });
+                continue;
+            }
+            coverage.push({
+                room: locator,
+                generation: replica.confirmed.record.transfer,
+                current: !(catching.has(locator) || owed.has(locator) || transfers.has(locator)),
+            });
+            for (const batch of replica.queue)
+                overlay.push(batch.id);
+        }
+        if (pending.length > 0)
+            return { pending };
+        return { coverage: { rooms: coverage, indexes: [], overlay } };
+    }
+    function awaitPreparation(cover) {
+        if (!('pending' in cover))
+            return;
+        const waiting = cover.pending.filter(({ awaits }) => awaits === 'preparation');
+        if (waiting.length > 0)
+            prepare(waiting.map(({ room }) => room));
+    }
+    function acquires(room) {
+        return (demanded(demand, room) ||
+            (replicas.get(room.locator)?.queue.length ?? 0) > 0 ||
+            queuesWithoutReplica.has(room.locator));
+    }
+    function acquiredLocators() {
+        return [...discovered.values()]
+            .filter(acquires)
+            .map((room) => room.locator)
+            .sort();
+    }
+    function heldDemand(acquired) {
+        if (demand.whole)
             return null;
-        return [...plan.reach.rooms, ...plan.reach.documents.map(roomOfKey)];
+        return { rooms: acquired.map((room) => room.locator), conversations: demand.conversations };
+    }
+    function applyDemand(next) {
+        const before = acquiredLocators();
+        const conversed = demand.conversations;
+        demand = next;
+        const after = acquiredLocators();
+        queueReadiness();
+        if (!conversed && next.conversations)
+            scheduleCurrency();
+        if (JSON.stringify(before) === JSON.stringify(after) && conversed === next.conversations)
+            return;
+        journal.record(`acquisition ${next.whole ? 'whole' : after.length}`);
+        if (options.adapter.roomStream === undefined)
+            void sync('unstreamed');
+        else if (socketOpen)
+            options.adapter.roomStream.reopen();
+    }
+    function acquire(next) {
+        if (closed)
+            return;
+        if (narrowing !== null)
+            clearTimeout(narrowing);
+        narrowing = null;
+        const widening = wider(next, demand);
+        if (!widening && !narrower(next, demand))
+            return;
+        if (widening || !roomsListed) {
+            applyDemand(next);
+            return;
+        }
+        // A narrower demand waits five seconds, so a tab that reloads returns before the stream reopens twice.
+        narrowing = setTimeout(() => {
+            narrowing = null;
+            applyDemand(next);
+        }, 5_000);
+    }
+    function requiredRooms(reach) {
+        if (reach === null)
+            return { listed: roomsListed, rooms: [...rooms.keys()].sort() };
+        const named = [...new Set(reach.rooms)].sort();
+        if (roomsListed)
+            return { listed: true, rooms: named.filter((room) => rooms.has(room)) };
+        return { listed: named.every((room) => replicas.has(room)), rooms: named };
+    }
+    function roomState(locator, search) {
+        if (sourceRefusals.has(locator))
+            return 'refused';
+        const listedRoom = discovered.get(locator);
+        if (roomsListed &&
+            (listedRoom === undefined ||
+                listedRoom.replica.admission !== 'admitted' ||
+                unreadable.has(locator)))
+            return 'unadmitted';
+        if (!replicas.has(locator))
+            return 'acquiring';
+        if (!prepared.has(locator))
+            return 'preparing';
+        if (search && !searchIndex.rooms().has(locator))
+            return 'indexing';
+        return 'complete';
+    }
+    function conversationCoverage(reach, search) {
+        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';
+    }
+    function connectionOf() {
+        if (socketOpen)
+            return 'connected';
+        if (status.providerUnreachable)
+            return 'unreachable';
+        return options.adapter.roomStream === undefined && status.lastCompleted !== null
+            ? '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 readinessFor(port, reach) {
+        const required = requiredRooms(reach);
+        const target = targets[port.target];
+        const search = target?.search === true;
+        const coverage = required.rooms.map((room) => ({ room, state: roomState(room, search) }));
+        const building = (state) => coverage
+            .filter((room) => room.state === state && !unindexable.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),
+                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),
+            lost: storageLoss !== null,
+            established: target?.established === true,
+        });
     }
-    function rowsQuery(plan) {
-        materialize(reachedRooms(plan));
-        return readSide.query(plan);
+    function keepTarget(name, change) {
+        const held = targets[name] ?? { established: false, search: false };
+        const next = { ...held, ...change };
+        if (next.established === held.established && next.search === held.search)
+            return;
+        targets = { ...targets, [name]: next };
+        queueReadiness();
+        void durably((local) => local.keepTargets(targets)).catch(() => {
+            journal.record(`target record failed ${name}`);
+        });
+    }
+    function deliverReadiness(watch) {
+        if (!readinessWatches.has(watch))
+            return;
+        const readiness = readinessFor(watch.port, watch.reach);
+        if (readiness.ready && targets[watch.port.target]?.established !== true) {
+            keepTarget(watch.port.target, { established: true });
+        }
+        const shown = JSON.stringify(readiness);
+        if (shown === watch.last)
+            return;
+        watch.last = shown;
+        watch.deliver(structuredClone(readiness));
+    }
+    function queueReadiness() {
+        if (readinessQueued || closed || readinessWatches.size === 0)
+            return;
+        readinessQueued = true;
+        queueMicrotask(() => {
+            readinessQueued = false;
+            if (closed)
+                return;
+            for (const watch of [...readinessWatches])
+                deliverReadiness(watch);
+        });
+    }
+    function watchReadiness(port, reach, deliver) {
+        const watch = { port, reach, deliver, last: null };
+        readinessWatches.add(watch);
+        void openLocal().then(() => deliverReadiness(watch), () => deliverReadiness(watch));
+        return () => {
+            readinessWatches.delete(watch);
+        };
+    }
+    function searching(target) {
+        if (targets[target]?.search !== true)
+            keepTarget(target, { search: true });
+    }
+    function layerBytes(layer) {
+        let bytes = 0;
+        for (const [path, text] of Object.entries(layer.documents))
+            bytes += (path.length + text.length) * 2;
+        return bytes;
+    }
+    function grownBy(next, previous) {
+        if (previous === undefined)
+            return layerBytes(next);
+        const documents = Object.fromEntries(Object.entries(next.documents).filter(([path, text]) => previous.documents[path] !== text));
+        return layerBytes({ ...next, documents });
+    }
+    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.quota - 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)
+            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);
+    }
+    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 === 'quota-exceeded' && (held.available === null || available <= held.available))
+            return;
+        resume();
+    }
+    function resume() {
+        if (rechecking !== null)
+            clearInterval(rechecking);
+        rechecking = null;
+        if (paused.size === 0 && capacity === null)
+            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) => {
+            const room = discovered.get(locator);
+            return room === undefined || !acquires(room);
+        });
+        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: 'quota-exceeded', needed: bytes, available });
+    }
+    async function rowsQuery(plan) {
+        const before = covered(plan);
+        awaitPreparation(before);
+        if ('pending' in before)
+            return before;
+        const { rows, at: cover } = await readSide.query(plan, () => covered(plan));
+        awaitPreparation(cover);
+        if ('pending' in cover)
+            return cover;
+        return 'groups' in rows
+            ? { groups: rows.groups, coverage: cover.coverage }
+            : { documents: rows.documents, coverage: cover.coverage };
+    }
+    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);
@@ -391,34 +886,7 @@ export function composeRuntime(options) {
             emitPresentation(app);
         conversations.changed(set);
     }
-    function stopTimer() {
-        if (resetTimer === undefined)
-            return;
-        clearTimeout(resetTimer);
-        resetTimer = undefined;
-    }
-    function armTimer() {
-        stopTimer();
-        if (closed || stopping)
-            return;
-        let earliest = null;
-        for (const { submission } of pendings.values()) {
-            if (submission.state !== 'reset')
-                continue;
-            const at = Date.parse(submission.reset);
-            if (earliest === null || at < earliest)
-                earliest = at;
-        }
-        if (earliest === null)
-            return;
-        // A Save House held back goes again only once the reset its answer named has passed.
-        resetTimer = setTimeout(() => {
-            resetTimer = undefined;
-            submitAll();
-        }, Math.max(0, earliest - Date.now()));
-    }
     async function refuse(reason, provider = null) {
-        stopTimer();
         discoveryPaused = true;
         try {
             if (reason === 'revoked-authorization') {
@@ -563,10 +1031,14 @@ export function composeRuntime(options) {
             rooms.delete(locator);
             roomDrafts.delete(locator);
             transfers.delete(locator);
+            catching.delete(locator);
             discovered.delete(locator);
             announced.delete(locator);
             unreadable.delete(locator);
             stale.delete(locator);
+            repairable.delete(locator);
+            unindexable.delete(locator);
+            paused.delete(locator);
             scopedRefusals.delete(locator);
             sourceRefusals.delete(locator);
             declarationRefusals.delete(locator);
@@ -582,7 +1054,9 @@ export function composeRuntime(options) {
             return fresh;
         publishChangeSet(mergeChangeSets(removed));
         for (const locator of fresh)
-            materialized.delete(locator);
+            prepared.delete(locator);
+        searchIndex.forget(fresh);
+        readSide.recover();
         moveTo({ ...status, ...attention() });
         return fresh;
     }
@@ -618,7 +1092,7 @@ export function composeRuntime(options) {
         return model;
     }
     async function hydrate(opened) {
-        const [records, queues, kept, presented, held, chatDrafts, lastCompleted, declared, named, known, staged,] = await Promise.all([
+        const [records, queues, kept, presented, held, chatDrafts, lastCompleted, declared, named, known, staged, heldTargets,] = await Promise.all([
             opened.all(),
             opened.queues(),
             opened.roomDrafts(),
@@ -630,7 +1104,9 @@ export function composeRuntime(options) {
             opened.capabilities(),
             opened.member(),
             opened.transfers(),
+            opened.targets(),
         ]);
+        targets = heldTargets;
         transfers.clear();
         for (const record of staged)
             transfers.set(record.locator, record);
@@ -692,6 +1168,7 @@ export function composeRuntime(options) {
     async function readState(opened) {
         const { lastCompleted, locators, read } = await hydrate(opened);
         applyChangeSet(read);
+        prepare();
         if (replicas.size > 0)
             emitRooms();
         if (member !== null)
@@ -807,17 +1284,19 @@ export function composeRuntime(options) {
             moveTo({ ...status, ...attention() });
             throw error;
         }
-        queuesWithoutReplica.delete(locator);
-        for (const { batch, returned } of unqueued) {
-            const outcome = localSaves ? 'dropped' : returned === null ? 'landed' : 'withdrawn';
-            journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
-        }
-        replicas.set(locator, replicaOf(confirmed, kept, before));
-        return changeSet(locator, before ?? null, replicas.get(locator) ?? null, {
-            room: settling.room,
-            queue: kept.length !== previousQueue.length,
-            drafts: [...written.keys()],
-        });
+        return () => {
+            queuesWithoutReplica.delete(locator);
+            for (const { batch, returned } of unqueued) {
+                const outcome = localSaves ? 'dropped' : returned === null ? 'landed' : 'withdrawn';
+                journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
+            }
+            replicas.set(locator, replicaOf(confirmed, kept, before));
+            return changeSet(locator, before ?? null, replicas.get(locator) ?? null, {
+                room: settling.room,
+                queue: kept.length !== previousQueue.length,
+                drafts: [...written.keys()],
+            });
+        };
     }
     function adoptModels(locator, record) {
         for (const [attached, model] of [
@@ -853,8 +1332,13 @@ export function composeRuntime(options) {
     function publish(local, room, confirmed, landing, live) {
         const { base, stored } = landing;
         return exclusive(async () => {
-            if (!live())
+            if (stored !== undefined) {
+                await indexReferrers({ text: confirmed.record.documents, binaries: confirmed.record.binaries }, compositionOf(confirmed.record));
+            }
+            if (!live()) {
+                caughtUpTo(room.locator);
                 return true;
+            }
             const prior = replicas.get(room.locator);
             if (base !== undefined &&
                 (prior?.confirmed.record.roomVersion !== base.record.roomVersion ||
@@ -868,17 +1352,33 @@ export function composeRuntime(options) {
                 const accepted = pendings.get(batch.id)?.accepted;
                 return (accepted !== undefined && options.adapter.reached(room.locator, roomVersion, accepted));
             });
-            const set = await settle(local, room.locator, prior, confirmed, queue.filter((batch) => !accepted.includes(batch)), { room: true, ...(stored === undefined ? {} : { stored }) });
-            if (stored !== undefined)
+            let settled;
+            try {
+                settled = await settle(local, room.locator, prior, confirmed, queue.filter((batch) => !accepted.includes(batch)), { room: true, ...(stored === undefined ? {} : { stored }) });
+            }
+            catch (error) {
+                if (!exceeded(error))
+                    throw error;
+                await exceededOn(room.locator, grownBy(confirmed.record, prior?.confirmed.record));
+                caughtUpTo(room.locator);
+                return true;
+            }
+            const set = settled();
+            if (stored !== undefined) {
                 transfers.delete(room.locator);
+                catching.delete(room.locator);
+            }
             for (const batch of accepted)
                 pendings.delete(batch.id);
             stale.delete(room.locator);
+            unindexable.delete(room.locator);
             if (unreadable.delete(room.locator))
                 scopedRefusals.delete(room.locator);
             sourceRefusals.delete(room.locator);
             declarationRefusals.delete(room.locator);
             list(room, true);
+            if (prior === undefined)
+                prepared.add(room.locator);
             publishChangeSet(set);
             moveTo({ ...status, ...attention() });
             options.adapter.roomStream?.published(room.locator, roomVersion);
@@ -887,6 +1387,7 @@ export function composeRuntime(options) {
     }
     async function saveRoomDrafts(locator, named, writtenBy) {
         const local = await openLocal();
+        await referenced(locator);
         const replica = replicas.get(locator);
         const room = rooms.get(locator);
         if (replica === undefined || room === undefined) {
@@ -934,6 +1435,11 @@ export function composeRuntime(options) {
             changes,
             bases: parts.flatMap(({ bases }) => bases),
             writtenBy,
+            clean: {
+                text: replica.confirmed.record.documents,
+                binaries: replica.confirmed.record.binaries,
+                composition: compositionOf(replica.confirmed.record),
+            },
         };
         const checked = withdrawing ? buildBatch({ ...input, queued: requeue.queued }) : null;
         if (checked?.kind === 'refused')
@@ -1274,8 +1780,20 @@ export function composeRuntime(options) {
             stage: (record, page) => exclusive(async () => {
                 if (!live())
                     return false;
-                await local.stage(record, page);
+                const bytes = layerBytes(page);
+                if (!(await admitted(local, record.locator, bytes)))
+                    return false;
+                try {
+                    await local.stage(record, page);
+                }
+                catch (error) {
+                    if (!exceeded(error))
+                        throw error;
+                    await exceededOn(record.locator, bytes);
+                    return false;
+                }
                 transfers.set(record.locator, record);
+                readSide.recover();
                 return true;
             }),
             abandon: (locator) => exclusive(async () => {
@@ -1283,6 +1801,7 @@ export function composeRuntime(options) {
                     return;
                 await local.abandon(locator);
                 transfers.delete(locator);
+                readSide.recover();
             }),
         };
     }
@@ -1295,6 +1814,10 @@ export function composeRuntime(options) {
     async function pullBootstrap(authorized, room, local, live) {
         if (!live())
             return unconfirmed;
+        if (replicas.has(room.locator)) {
+            catching.add(room.locator);
+            readSide.recover();
+        }
         try {
             const result = await bootstrapRoom(options.adapter, authorized, room, {
                 collection: modelOf(room.locator),
@@ -1302,14 +1825,24 @@ export function composeRuntime(options) {
             }, (models, held) => (live() ? remodel(room.locator, models, held) : held), live, staging(local, live), reusable(room));
             const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
+            if (result.kind !== 'staged')
+                caughtUpTo(room.locator);
             return result;
         }
         catch (error) {
             journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
+            caughtUpTo(room.locator);
             throw error;
         }
     }
+    function caughtUpTo(locator) {
+        if (catching.delete(locator))
+            readSide.recover();
+    }
     async function advance(room, local, authorized, live) {
+        await referenced(room.locator);
+        if (!live() || paused.has(room.locator))
+            return unconfirmed;
         const held = replicas.get(room.locator);
         if (held !== undefined) {
             const refreshed = await pullRefresh(authorized, held.confirmed, live);
@@ -1340,6 +1873,7 @@ export function composeRuntime(options) {
                 return refreshed;
             if (opened !== null) {
                 owed.add(room.locator);
+                readSide.recover();
                 return unconfirmed;
             }
         }
@@ -1352,10 +1886,19 @@ export function composeRuntime(options) {
         return null;
     }
     async function withhold(withheld, room, local, progress) {
+        if (withheld.kind === 'unconfirmed')
+            return;
         if (withheld.kind === 'refused')
             stale.delete(room.locator);
         else
             stale.add(room.locator);
+        if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
+            const reset = withheld.kind === 'retryable-refusal' ? withheld.reset : undefined;
+            repairable.set(room.locator, reset);
+            repairLater(room.locator, reset === undefined ? { again: true } : { at: Date.parse(reset) });
+        }
+        else
+            repairable.delete(room.locator);
         if (withheld.kind === 'scoped-refusal') {
             await scoped(withheld, room, local);
         }
@@ -1391,6 +1934,7 @@ export function composeRuntime(options) {
         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) {
@@ -1412,6 +1956,7 @@ export function composeRuntime(options) {
             (accepted.time === undefined ? '' : ` time ${accepted.time}`));
     }
     async function adoptAccepted(room, local, submitted, accepted) {
+        await referenced(room.locator);
         if (!continuing())
             return unconfirmed;
         const current = replicas.get(room.locator);
@@ -1433,11 +1978,12 @@ export function composeRuntime(options) {
             emitQueue(room.locator);
             return applied;
         }
-        const set = await settle(local, room.locator, current, applied.confirmed, current.queue.filter((batch) => batch.id !== submitted.id), { room: true });
+        const settled = await settle(local, room.locator, current, applied.confirmed, current.queue.filter((batch) => batch.id !== submitted.id), { room: true });
         pendings.delete(submitted.id);
         unreadable.delete(room.locator);
         sourceRefusals.delete(room.locator);
         declarationRefusals.delete(room.locator);
+        const set = settled();
         list(room, true);
         publishChangeSet(set);
         moveTo({ ...status, ...attention() });
@@ -1451,14 +1997,14 @@ export function composeRuntime(options) {
             refusedSource(room, failed);
         return false;
     }
-    async function submitRoom(room, local, authorized, progress) {
-        while (continuing() && authorization !== undefined) {
+    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];
             if (replica === undefined || head === undefined)
-                return;
+                return 'done';
             if (pendings.get(head.id)?.accepted !== undefined)
-                return;
+                return 'done';
             const state = pendings.get(head.id);
             const { submission, lost: earlier } = state ?? {
                 submission: { state: 'waiting' },
@@ -1466,24 +2012,30 @@ export function composeRuntime(options) {
             };
             if (submission.state === 'reset' && Date.now() < Date.parse(submission.reset)) {
                 progress.complete = false;
-                return;
+                return { at: Date.parse(submission.reset) };
             }
             if (writesHeld()) {
                 progress.complete = false;
                 journal.record(`submission ${room.locator} ${head.id} held`);
-                return;
+                return 'done';
             }
             const lost = earlier || submission.state === 'submitted';
+            if (lost && pastHorizon(head.id)) {
+                await discardPending(room, local, signal);
+                return 'done';
+            }
             let result;
             journal.record(`submission ${room.locator} ${head.id}`);
             await exclusive(() => mark(local, room.locator, head.id, { state: 'submitted' }, lost));
             if (discoveryPaused || fences.has(room.locator))
-                return;
-            if (writesHeld()) {
+                return 'done';
+            if (signal.aborted || writesHeld()) {
                 await exclusive(() => mark(local, room.locator, head.id, submission, earlier));
+                if (signal.aborted)
+                    return 'done';
                 progress.complete = false;
                 journal.record(`submission ${room.locator} ${head.id} held`);
-                return;
+                return 'done';
             }
             const opensBefore = openSignals;
             const answered = awaitingAnswer(room.locator);
@@ -1499,32 +2051,36 @@ export function composeRuntime(options) {
                 progress.complete = false;
                 if (continuing())
                     progress.reachable = false;
-                return;
+                return 'again';
+            }
+            if (signal.aborted) {
+                answered();
+                return 'done';
             }
             if (result.kind !== 'accepted' || !continuing())
                 answered();
             if (!continuing())
-                return;
+                return 'done';
             if (result.kind === 'transport-uncertainty') {
                 progress.complete = false;
                 progress.reachable = false;
-                return;
+                return 'again';
             }
             if (result.kind === 'room-not-readable') {
                 progress.complete = false;
                 unreadable.add(room.locator);
                 list(room, false);
                 emitRooms();
-                return;
+                return 'done';
             }
             if (result.kind === 'revoked-authorization') {
                 await refuse('revoked-authorization');
-                return;
+                return 'done';
             }
             if (result.kind === 'scoped-refusal') {
                 await scoped(result, room, local);
                 progress.complete = false;
-                return;
+                return 'done';
             }
             if (result.kind === 'write-halted') {
                 journal.record(`outcome ${room.locator} ${head.id} write-halted`);
@@ -1533,16 +2089,24 @@ export function composeRuntime(options) {
                     continue;
                 haltedRefusal = true;
                 progress.complete = false;
-                return;
+                return 'done';
             }
             if (result.kind === 'conflicted' ||
                 result.kind === 'rejected' ||
                 result.kind === 'expired' ||
                 result.kind === 'retryable-refusal') {
+                if (result.kind === 'expired' && lost && result.restored !== true) {
+                    journal.record(`outcome ${room.locator} ${head.id} expired`);
+                    await discardPending(room, local, signal);
+                    return 'done';
+                }
                 if (result.kind === 'expired') {
+                    await exclusive(() => mark(local, room.locator, head.id, { state: 'waiting' }, false));
                     const withheld = await advance(room, local, authorized, continuing);
-                    if (withheld !== null)
-                        return withhold(withheld, room, local, progress);
+                    if (withheld !== null) {
+                        await withhold(withheld, room, local, progress);
+                        return 'done';
+                    }
                 }
                 journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` +
                     (result.kind === 'conflicted' && result.roomVersion !== undefined
@@ -1555,8 +2119,7 @@ export function composeRuntime(options) {
                 const reset = result.reset;
                 progress.complete = false;
                 await exclusive(() => mark(local, room.locator, head.id, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
-                armTimer();
-                return;
+                return reset === undefined ? 'again' : { at: Date.parse(reset) };
             }
             if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
                 const left = leaving(head, result);
@@ -1567,28 +2130,73 @@ export function composeRuntime(options) {
                     if (current === undefined || !current.queue.some((batch) => batch.id === head.id)) {
                         return;
                     }
-                    const set = await settle(local, room.locator, current, current.confirmed, current.queue.filter((batch) => batch.id !== head.id), {
+                    const settled = await settle(local, room.locator, current, current.confirmed, current.queue.filter((batch) => batch.id !== head.id), {
                         leaving: (result.kind === 'expired' && landed(head, current.confirmed)) ||
                             (result.kind === 'conflicted' && landed(head, current.confirmed, result.affected))
                             ? { ...left, returned: null }
                             : left,
                     });
-                    publishChangeSet(set);
+                    publishChangeSet(settled());
                     moveTo({ ...status, ...attention() });
                 });
                 if (result.kind === 'expired')
                     continue;
                 const withheld = await advance(room, local, authorized, continuing);
-                if (withheld !== null)
-                    return withhold(withheld, room, local, progress);
+                if (withheld !== null) {
+                    await withhold(withheld, room, local, progress);
+                    return 'done';
+                }
                 continue;
             }
             const kept = await adopted(room, local, head, result).finally(answered);
             if (!kept) {
                 progress.complete = false;
-                return;
+                return 'done';
             }
         }
+        return 'done';
+    }
+    function pastHorizon(identity) {
+        return (outcomeRetention !== null && identityTime(identity) + outcomeRetention * 1000 <= Date.now());
+    }
+    async function discardPending(room, local, signal) {
+        const { locator } = room;
+        const discarded = await exclusive(async () => {
+            if (fences.has(locator))
+                return false;
+            const before = replicas.get(locator);
+            const queue = before?.queue ?? queuesWithoutReplica.get(locator) ?? [];
+            fences.set(locator, { at: discoveries, erased: false });
+            lastFenced.set(locator, ++fencings);
+            try {
+                await local.discard(locator);
+            }
+            finally {
+                fences.delete(locator);
+            }
+            for (const batch of queue)
+                pendings.delete(batch.id);
+            queuesWithoutReplica.delete(locator);
+            const after = before === undefined ? null : replicaOf(before.confirmed, [], before);
+            if (after !== null)
+                replicas.set(locator, after);
+            journal.record(`room discarded ${locator}`);
+            publishChangeSet(changeSet(locator, before ?? null, after, { queue: true }));
+            moveTo({ ...status, ...attention() });
+            return true;
+        });
+        if (!discarded)
+            return;
+        const progress = { complete: true, reachable: true };
+        await roomTask(locator, async (live) => {
+            await Promise.race([
+                reload(room, local, progress, () => live() && !signal.aborted),
+                abandonedOn(signal),
+            ]);
+        });
+        if (signal.aborted)
+            return;
+        await rest(progress);
     }
     function awaitingAnswer(locator) {
         let release = () => { };
@@ -1714,15 +2322,16 @@ export function composeRuntime(options) {
         });
     }
     async function synchronize(listed, local, progress, attempt, live) {
-        const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(room, local, progress)));
+        const acquired = listed.filter(acquires);
+        const prepared = await Promise.allSettled(acquired.map((room) => prepareRoom(room, local, progress)));
         if (!live())
             return;
-        const ready = listed.filter((_, index) => {
+        const ready = acquired.filter((_, index) => {
             const outcome = prepared[index];
             return outcome?.status === 'fulfilled' && outcome.value;
         });
         if (attempt === 'opened') {
-            options.adapter.roomStream?.hold(heldRooms(ready));
+            options.adapter.roomStream?.hold(heldRooms(ready), heldDemand(acquired));
             handed = true;
         }
         discovering?.release();
@@ -1789,17 +2398,22 @@ export function composeRuntime(options) {
         await caughtUp(room, local, progress, live);
     }
     async function reload(room, local, progress, live) {
-        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);
-            return;
+        try {
+            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);
+                return;
+            }
+            await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored }, live);
+            await caughtUp(room, local, progress, live);
+        }
+        finally {
+            caughtUpTo(room.locator);
         }
-        await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored }, live);
-        await caughtUp(room, local, progress, live);
     }
     async function discoverRooms(local, progress, attempt, live) {
         if (closed || authorization === undefined) {
@@ -1875,6 +2489,7 @@ export function composeRuntime(options) {
         }
         const previousCapabilities = capabilities;
         capabilities = result.capabilities;
+        outcomeRetention = result.retention.outcome;
         notifyReady();
         if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits) ||
             JSON.stringify(result.capabilities) !== JSON.stringify(previousCapabilities)) {
@@ -2004,6 +2619,8 @@ export function composeRuntime(options) {
         const progress = underway?.generation === generation ? underway.progress : null;
         const cycle = progress ?? { complete: true, reachable: true };
         const replacing = reloadNow((room) => expired.includes(room.locator), cycle);
+        if (opened === generation)
+            opened = null;
         return task(OPENING_LANE, async (live) => {
             underway = null;
             if (!live())
@@ -2016,8 +2633,6 @@ export function composeRuntime(options) {
             await roomsCarried(expired);
             if (!live())
                 return;
-            if (opened === generation)
-                opened = null;
             const replaced = new Set(owed);
             owed.clear();
             try {
@@ -2025,6 +2640,9 @@ export function composeRuntime(options) {
                 const held = [...discovered.values()].filter((room) => replicas.has(room.locator));
                 const reloading = held.filter((room) => !expired.includes(room.locator) &&
                     (replaced.has(room.locator) || revoked(room.locator)));
+                for (const room of reloading)
+                    catching.add(room.locator);
+                readSide.recover();
                 const reloads = Promise.allSettled(reloading.map((room) => roomTask(room.locator, (current) => reload(room, local, progress, current))));
                 const reloaded = [...(await reloads), ...(await replacing)];
                 if (progress.reachable) {
@@ -2069,38 +2687,94 @@ export function composeRuntime(options) {
     function submitLater(locator) {
         if (localSaves)
             return;
-        const running = submitting.get(locator);
-        if (running !== undefined) {
-            running.again = true;
+        void recovery.attempt(`submit ${locator}`, (signal) => submitPass(locator, signal));
+    }
+    async function submitPass(locator, signal) {
+        const room = discovered.get(locator);
+        if (closed || stopping || discoveryPaused || room === undefined)
+            return 'done';
+        const progress = { complete: true, reachable: true };
+        let next;
+        try {
+            await ensureAuthorization();
+            if (authorization === undefined)
+                return 'done';
+            next = await submitRoom(room, await openLocal(), authorization, progress, signal);
+        }
+        catch {
+            progress.reachable = false;
+            next = 'again';
+        }
+        if (signal.aborted)
+            return 'done';
+        await rest(progress);
+        return next === 'again' && !socketOpen ? 'done' : next;
+    }
+    function repairLater(locator, when) {
+        if (!socketOpen || repairing.has(locator))
             return;
+        void recovery.attempt(`repair ${locator}`, (signal) => repairPass(locator, signal), when);
+    }
+    async function repairPass(locator, signal) {
+        const room = discovered.get(locator);
+        if (!socketOpen || closed || stopping || discoveryPaused || !stale.has(locator))
+            return 'done';
+        if (room === undefined || room.replica.admission !== 'admitted')
+            return 'done';
+        const progress = { complete: true, reachable: true };
+        repairing.add(locator);
+        try {
+            const local = await openLocal();
+            await roomTask(locator, async (live) => {
+                const current = () => live() && !signal.aborted;
+                if (!current() || authorization === undefined)
+                    return;
+                const withheld = await Promise.race([
+                    advance(room, local, authorization, current),
+                    abandonedOn(signal),
+                ]);
+                if (withheld !== null && current())
+                    await withhold(withheld, room, local, progress);
+            });
         }
-        const run = { again: false, done: Promise.resolve() };
-        submitting.set(locator, run);
-        run.done = (async () => {
-            try {
-                do {
-                    run.again = false;
-                    const room = discovered.get(locator);
-                    if (closed || stopping || discoveryPaused || room === undefined)
-                        return;
-                    const progress = { complete: true, reachable: true };
-                    try {
-                        await ensureAuthorization();
-                        if (authorization === undefined)
-                            return;
-                        await submitRoom(room, await openLocal(), authorization, progress);
-                    }
-                    catch {
-                        progress.reachable = false;
-                    }
-                    armTimer();
-                    await rest(progress);
-                } while (run.again);
-            }
-            finally {
-                submitting.delete(locator);
-            }
-        })();
+        catch {
+            stale.add(locator);
+            progress.reachable = false;
+        }
+        finally {
+            repairing.delete(locator);
+        }
+        if (signal.aborted)
+            return 'done';
+        await rest(progress);
+        if (!stale.has(locator)) {
+            if ((replicas.get(locator)?.queue.length ?? 0) > 0)
+                submitLater(locator);
+            return 'done';
+        }
+        if (!repairable.has(locator))
+            return 'done';
+        const reset = repairable.get(locator);
+        return reset === undefined ? 'again' : { at: Date.parse(reset) };
+    }
+    function resendLater() {
+        if (!socketOpen)
+            return;
+        void recovery.attempt('resend', resendPass, { again: true });
+    }
+    async function resendPass(signal) {
+        if (!socketOpen || closed || stopping || discoveryPaused)
+            return 'done';
+        const reading = { complete: true, reachable: true };
+        try {
+            await conversations.resend(reading);
+        }
+        catch {
+            reading.reachable = false;
+        }
+        if (signal.aborted)
+            return 'done';
+        return reading.reachable && reading.complete ? 'done' : 'again';
     }
     function submitAll() {
         for (const [locator, replica] of replicas) {
@@ -2115,15 +2789,21 @@ export function composeRuntime(options) {
                 return;
             }
             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 (demand.conversations)
+                await conversations.catchUp(reading);
             if (progress.reachable && reading.reachable)
                 await conversations.resend(reading);
-            if (!reading.reachable)
+            if (!reading.reachable) {
                 progress.reachable = false;
+                resendLater();
+            }
         }
         catch {
             progress.complete = false;
@@ -2180,7 +2860,7 @@ export function composeRuntime(options) {
                 return;
             const room = discovered.get(locator);
             const held = replicas.get(locator);
-            if (room === undefined || room.replica.admission !== 'admitted')
+            if (room === undefined || room.replica.admission !== 'admitted' || !acquires(room))
                 return;
             if (held !== undefined &&
                 (held.confirmed.record.replica.selection !== room.replica.selection ||
@@ -2232,6 +2912,8 @@ export function composeRuntime(options) {
             if (event.kind === 'opened') {
                 socketOpen = true;
                 generation += 1;
+                conversations.reopened();
+                recovery.resume();
                 void sync('opened');
             }
             else if (event.kind === 'closed')
@@ -2255,6 +2937,7 @@ export function composeRuntime(options) {
             haltedRefusal = false;
         if (mode !== serviceMode) {
             serviceMode = mode;
+            queueReadiness();
             journal.record(`service mode ${mode}`);
             for (const listener of serviceModeListeners)
                 listener(mode);
@@ -2267,6 +2950,8 @@ export function composeRuntime(options) {
         if (stream === undefined || withdrawConversations !== undefined)
             return;
         withdrawConversations = stream.observe((event) => {
+            if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted')
+                queueReadiness();
             if (conversations.receive(event)) {
                 void ready.then(scheduleCurrency);
                 return;
@@ -2289,7 +2974,7 @@ export function composeRuntime(options) {
         if (!live())
             return;
         await conversations.reconcile();
-        if (conversations.current()) {
+        if (conversations.current() || !demand.conversations) {
             show();
             return;
         }
@@ -2307,13 +2992,18 @@ export function composeRuntime(options) {
         if (closed)
             return;
         closed = true;
+        if (narrowing !== null)
+            clearTimeout(narrowing);
+        if (rechecking !== null)
+            clearInterval(rechecking);
+        readinessWatches.clear();
         withdrawStream?.();
         withdrawStream = undefined;
         withdrawConversations?.();
         withdrawConversations = undefined;
         withdrawServiceMode?.();
         conversations.close();
-        stopTimer();
+        void recovery.retire();
         store?.close();
         void opening?.then((opened) => {
             opened.close();
@@ -2331,9 +3021,8 @@ export function composeRuntime(options) {
     }
     async function stop() {
         stopping = true;
-        stopTimer();
+        await recovery.retire();
         await Promise.all(working);
-        await Promise.all([...submitting.values()].map((run) => run.done));
         await mutations;
         close();
     }
@@ -2355,17 +3044,54 @@ export function composeRuntime(options) {
         return planOf(input, roomFacts(reach), planReach(reach));
     }
     function watchPlan(plan, deliver) {
-        materialize(reachedRooms(plan));
-        return readSide.watch(plan, identityOf(plan), deliver);
+        return readSide.watch(plan, identityOf(plan), () => {
+            const cover = covered(plan);
+            awaitPreparation(cover);
+            return cover;
+        }, deliver);
     }
     async function searched(input, reach) {
         const plan = searchPlanOf(input);
-        const selected = plan.documents === undefined && reach === null
-            ? null
-            : (await rowsQuery(filterOf(plan.documents ?? {}, roomFacts(reach), planReach(reach)))).documents;
-        if (selected === null)
-            materialize(null);
-        return searchIndex.search(reach === null || reach.conversations ? plan : { ...plan, conversations: [] }, selected);
+        const filter = filterOf(plan.documents ?? {}, roomFacts(reach), planReach(reach));
+        for (;;) {
+            const cover = covered(filter);
+            awaitPreparation(cover);
+            const pending = 'pending' in cover ? [...cover.pending] : [];
+            const covering = 'pending' in cover ? [] : cover.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 held = conversations.searchable();
+            const named = reach !== null && !reach.conversations
+                ? []
+                : (plan.conversations ?? held).filter((one) => held.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);
+            if (pending.length > 0 || 'pending' in cover)
+                return { pending };
+            const seen = searchIndex.changes();
+            await searchIndex.caughtUp();
+            const selected = plan.documents === undefined && reach === null ? null : await rowsQuery(filter);
+            if (selected !== null && 'pending' in selected)
+                return selected;
+            if (searchIndex.changes() !== seen ||
+                JSON.stringify(covered(filter)) !== JSON.stringify(cover))
+                continue;
+            return {
+                ...searchIndex.search(plan, selected === null ? null : selected.documents, named),
+                coverage: {
+                    rooms: covering,
+                    conversations: named,
+                    index: searchIndex.generation(),
+                    overlay: cover.coverage.overlay,
+                },
+            };
+        }
     }
     const watch = (topic, input, deliver) => {
         if (topic === 'room-drafts') {
@@ -2411,6 +3137,9 @@ export function composeRuntime(options) {
                 presentationListeners.delete(listener);
             };
         }
+        if (topic === 'readiness') {
+            return watchReadiness({ target: '', code: 'stored', capacity: null }, null, deliver);
+        }
         if (topic === 'rooms') {
             roomListeners.add(deliver);
             deliver(listed());
@@ -2577,7 +3306,13 @@ export function composeRuntime(options) {
             return journal.export();
         },
         persistence() {
-            return options.shell.persistentStorage;
+            return persistence === 'granted';
+        },
+        async retry() {
+            journal.record('retry');
+            unindexable.clear();
+            queueReadiness();
+            resume();
         },
         observe: observing(watch),
         async reauthorize() {
@@ -2604,6 +3339,22 @@ export function composeRuntime(options) {
         query: (plan) => rowsQuery(plan),
         watchPlan,
         search: searched,
+        searching,
+        watchReadiness,
+    };
+    return {
+        md,
+        stop,
+        lose: loseRooms,
+        watch,
+        acquire,
+        persisted(answer) {
+            if (answer === persistence)
+                return;
+            persistence = answer;
+            journal.record(`persistence ${answer}`);
+            queueReadiness();
+        },
+        within: (reach, port) => narrowed(reachable, reach, port),
     };
-    return { md, stop, lose: loseRooms, watch, within: (reach) => narrowed(reachable, reach) };
 }