@agentshouse/mdruntime 0.1.0-ce531b51ff088 → 0.1.0-cff8ba8fa2542

package/dist/connection.js

@@ -1,14 +1,13 @@
-import { verify } from '@agentshouse/mdmodel';
+import { attachedModel } from './attached-model.js';
 import { cached, modelTypes, NO_MODEL, sameModel, } from './model.js';
-import { opened } from './observation.js';
+import { observing } from './observation.js';
 import { filterOf, identityOf, planOf, } from './query.js';
 import { createReadSide } from './read-side.js';
 import { createSearchIndex, searchPlanOf, } from './search.js';
-import { ROOM_CONTRACT_VERSION, VERSION_1_CAPABILITIES, } from './adapter.js';
 import { bootstrapRoom } from './bootstrap.js';
 import { changeSet, mergeChangeSets } from './change-set.js';
 import { createConversationStore, } from './conversation.js';
-import { MD_MODEL, parseCollection, validRoot } from './collection.js';
+import { parseCollection, validRoot } from './collection.js';
 import { createLog } from './log.js';
 import { refreshRoom } from './refresh.js';
 import { buildBatch } from './save.js';
@@ -20,37 +19,21 @@ import { roomDraftRevision } from './identity.js';
 import { beneath, normalize } from './paths.js';
 import { openRuntimeStore, } from './store.js';
 import { unconfirmed } from './transfer.js';
-// Discovery repeats each minute so a Room the stream stopped serving stays unrefreshed no longer.
-const DEFAULT_DISCOVERY_INTERVAL_MS = 60_000;
-const EMPTY_SCHEMA = { verdict: 'accept', model: { types: {} } };
-const knownCapabilities = new Set(VERSION_1_CAPABILITIES);
+import { governs, holds, narrowed, planReach, } from './reach.js';
 function within(root, path) {
     return root === '' || beneath(root, path);
 }
-function declaredIdentity(model) {
-    if (model === undefined)
-        return false;
-    if (model === null)
-        return true;
-    return (typeof model.identity === 'string' &&
-        model.identity.length > 0 &&
-        typeof model.version === 'string' &&
-        model.version.length > 0);
-}
 function declaredSelection(room) {
     const selection = room.typedSelection;
     if (selection === undefined)
         return true;
     if (!Array.isArray(selection.roots) || selection.roots.length === 0)
         return false;
-    if (!declaredIdentity(selection.attachedModel))
-        return false;
     return selection.roots.every((root, index) => validRoot(root) &&
         root !== '' &&
         selection.roots.every((other, at) => at === index || !within(other, root)));
 }
 export function composeRuntime(options) {
-    const period = options.discoveryIntervalMs ?? DEFAULT_DISCOVERY_INTERVAL_MS;
     let authorization = options.authorization;
     let opening;
     let store;
@@ -58,20 +41,13 @@ export function composeRuntime(options) {
     const pendings = new Map();
     const roomDrafts = new Map();
     const presentations = new Map();
-    const wanted = new Map();
     let limits = [];
     let capabilities = [];
-    function rewriting() {
-        return capabilities.some((capability) => capability.name === 'move-reference-rewrites')
-            ? 'provider'
-            : 'runtime';
-    }
     const rooms = new Map();
     const unreadable = new Set();
     const models = new Map();
     const liveModels = new Map();
     const invalidModels = new Set();
-    const modelEpoch = new Map();
     const discovered = new Map();
     let roomsListed = false;
     const scopedRefusals = new Map();
@@ -100,16 +76,19 @@ export function composeRuntime(options) {
     let status = STARTING;
     let shown = STARTING;
     let discoveryPaused = false;
-    let timer;
+    let resetTimer;
     let closed = false;
     let stopping = false;
-    let withdrawNotifications;
-    let handed;
-    const notices = new Map();
+    let withdrawStream;
+    const announced = new Map();
+    let underway = null;
+    const submitting = new Map();
+    const answering = new Map();
+    let complete = false;
+    let recorded = false;
+    const stale = new Set();
     let chain = Promise.resolve();
     let mutations = Promise.resolve();
-    let inflight = false;
-    let queued = false;
     const roomListeners = new Set();
     const refusalListeners = new Set();
     const storageLossListeners = new Set();
@@ -120,12 +99,13 @@ export function composeRuntime(options) {
     const readSide = createReadSide();
     let withdrawConversations;
     let currencyQueued = false;
+    let socketOpen = false;
     let serviceMode = 'open';
     let haltedRefusal = false;
     let openSignals = 0;
     const serviceModeListeners = new Set();
     const conversations = createConversationStore({
-        cards: declaredCards,
+        agents: declaredAgents,
         documents: (locator) => readSide.query(planOf({ rooms: [locator], select: 'all' }, roomFacts())),
         call: (name, input) => invokeAction(name, input),
         durably,
@@ -234,11 +214,14 @@ export function composeRuntime(options) {
     function listed() {
         return structuredClone([...rooms.values()]);
     }
-    function roomFacts() {
-        const held = [...rooms.values()].map((room) => {
+    function roomFacts(reach = null) {
+        const held = [...rooms.values()]
+            .filter((room) => holds(reach, room.locator))
+            .map((room) => {
+            const governed = governs(reach, room);
             const attached = [
-                modelOf(room.locator),
-                ...(room.typedSelection === null ? [] : [modelOf(room.locator, 'typed-selection')]),
+                ...(governed.collection ? [modelOf(room.locator)] : []),
+                ...(governed.selection ? [modelOf(room.locator, 'typed-selection')] : []),
             ];
             return {
                 locator: room.locator,
@@ -316,23 +299,32 @@ export function composeRuntime(options) {
         for (const app of set.presentations)
             emitPresentation(app);
         conversations.changed(set);
-        const cards = declaredCards();
-        if (cards !== undefined && set.documents.some((change) => change.locator === cards.locator)) {
-            scheduleCurrency();
-        }
     }
     function stopTimer() {
-        if (timer === undefined)
+        if (resetTimer === undefined)
             return;
-        clearInterval(timer);
-        timer = undefined;
+        clearTimeout(resetTimer);
+        resetTimer = undefined;
     }
-    function startTimer() {
-        if (timer !== 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;
-        timer = setInterval(() => {
-            void enqueue();
-        }, period);
+        // 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();
@@ -358,7 +350,6 @@ export function composeRuntime(options) {
                     }
                     for (const key of keys) {
                         invalidModels.add(key);
-                        modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
                         models.set(key, revoked);
                         liveModels.delete(key);
                     }
@@ -373,7 +364,7 @@ export function composeRuntime(options) {
                             };
                             const read = readConfirmed(record, before.confirmed);
                             replicas.set(locator, read.kind === 'staged'
-                                ? replicaOf(read.confirmed, before.queue, rewriting(), before)
+                                ? replicaOf(read.confirmed, before.queue, before)
                                 : { ...before, confirmed: { ...before.confirmed, record } });
                         }
                         rooms.set(locator, {
@@ -406,13 +397,11 @@ export function composeRuntime(options) {
             locator: room.locator,
             operations: room.operations,
             replica: room.replica,
-            attachedModel: room.attachedModel,
             model: modelTypes(modelOf(room.locator)),
             typedSelection: selection === null
                 ? null
                 : {
                     roots: selection.roots,
-                    attachedModel: selection.attachedModel,
                     model: modelTypes(modelOf(room.locator, 'typed-selection')),
                 },
             providerOwnedPaths: room.providerOwnedPaths,
@@ -429,9 +418,6 @@ export function composeRuntime(options) {
         discovered.clear();
         for (const room of listed)
             discovered.set(room.locator, room);
-        for (const locator of wanted.keys())
-            if (!listedLocators.has(locator))
-                wanted.delete(locator);
         await dropUnlisted(listedLocators, local);
         for (const room of listed) {
             const held = replicas.get(room.locator)?.confirmed.record;
@@ -465,6 +451,7 @@ export function composeRuntime(options) {
                 rooms.delete(locator);
                 roomDrafts.delete(locator);
                 unreadable.delete(locator);
+                stale.delete(locator);
                 scopedRefusals.delete(locator);
                 sourceRefusals.delete(locator);
                 declarationRefusals.delete(locator);
@@ -473,7 +460,6 @@ export function composeRuntime(options) {
                     models.delete(key);
                     liveModels.delete(key);
                     invalidModels.delete(key);
-                    modelEpoch.delete(key);
                 }
                 journal.record(`room unlisted ${locator}`);
             }
@@ -486,7 +472,6 @@ export function composeRuntime(options) {
         if (prior !== undefined &&
             prior.status !== 'unavailable' &&
             (persisted.status === 'unavailable' || !sameModel(prior.snapshot, persisted.snapshot))) {
-            modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
             invalidModels.add(key);
         }
         const model = persisted.status === 'unavailable' ||
@@ -541,7 +526,7 @@ export function composeRuntime(options) {
                     record: retyped,
                     collection: parseCollection(retyped.documents, compositionOf(retyped)),
                 };
-            replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? [], rewriting(), prior));
+            replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? [], prior));
             const existing = rooms.get(record.locator);
             if (existing === undefined)
                 list(record, false);
@@ -552,13 +537,11 @@ export function composeRuntime(options) {
                     attachments: record.attachments,
                     operations: record.operations,
                     replica: record.replica,
-                    attachedModel: record.attachedModel,
                     model: modelTypes(model),
                     typedSelection: record.typedSelection === null
                         ? null
                         : {
                             roots: record.typedSelection.roots,
-                            attachedModel: record.typedSelection.attachedModel,
                             model: modelTypes(selectionModel),
                         },
                 });
@@ -626,7 +609,7 @@ export function composeRuntime(options) {
         return state !== undefined && state.submission.state !== 'submitted' && !state.lost;
     }
     async function settle(local, locator, before, confirmed, queue, settling = {}) {
-        const withdrawn = withdrawals(confirmed, queue, withdrawable, rewriting());
+        const withdrawn = withdrawals(confirmed, queue, withdrawable);
         const kept = queue.filter((batch) => !withdrawn.includes(batch));
         const returning = [
             ...withdrawn.map((batch) => ({ batch, returned: { kind: 'withdrawn' } })).reverse(),
@@ -662,42 +645,73 @@ export function composeRuntime(options) {
             rememberRoomDraft(record);
         for (const batch of withdrawn)
             journal.record(`outcome ${locator} ${batch.id} withdrawn`);
-        replicas.set(locator, replicaOf(confirmed, kept, rewriting(), before));
+        replicas.set(locator, replicaOf(confirmed, kept, before));
         return changeSet(locator, before ?? null, replicas.get(locator) ?? null, {
             room: settling.room,
             queue: kept.length !== (before?.queue.length ?? 0),
             drafts: [...written.keys()],
         });
     }
-    function publish(local, room, confirmed) {
+    function adoptModels(locator, record) {
+        for (const [attached, model] of [
+            ['collection', record.model],
+            ['typed-selection', record.selectionModel],
+        ]) {
+            const key = modelKey(locator, attached);
+            models.set(key, model);
+            invalidModels.delete(key);
+            if (model.status === 'current')
+                liveModels.set(key, JSON.stringify(model.snapshot));
+            else if (model.status === 'unavailable')
+                liveModels.delete(key);
+        }
+    }
+    function remodel(locator, answers, held) {
+        const taken = (answer, previous, attached) => {
+            if (answer === undefined)
+                return previous;
+            const { state, refused } = attachedModel(answer, previous);
+            if (refused !== null) {
+                const where = refused.location === undefined ? '' : ` ${refused.location}`;
+                journal.record(`model invalid ${locator} ${attached} ${refused.identity} ${refused.rule}${where}`);
+            }
+            models.set(modelKey(locator, attached), state);
+            return state;
+        };
+        return {
+            collection: taken(answers?.collection, held.collection, 'collection'),
+            selection: taken(answers?.selection, held.selection, 'typed-selection'),
+        };
+    }
+    function publish(local, room, confirmed, base) {
         return exclusive(async () => {
             if (!continuing())
-                return;
+                return true;
             const prior = replicas.get(room.locator);
-            const retained = readConfirmed({
-                ...confirmed.record,
-                model: modelOf(room.locator),
-                selectionModel: modelOf(room.locator, 'typed-selection'),
-            }, prior?.confirmed);
-            if (retained.kind !== 'staged')
-                throw new Error(`Cannot retype staged Room ${room.locator}`);
+            if (base !== undefined &&
+                (prior?.confirmed.record.roomVersion !== base.record.roomVersion ||
+                    prior.confirmed.record.revisions !== base.record.revisions)) {
+                return false;
+            }
+            adoptModels(room.locator, confirmed.record);
             const queue = prior?.queue ?? [];
-            const roomVersion = retained.confirmed.record.roomVersion;
+            const roomVersion = confirmed.record.roomVersion;
             const accepted = queue.filter((batch) => {
                 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, retained.confirmed, queue.filter((batch) => !accepted.includes(batch)), { room: true });
-            const target = wanted.get(room.locator);
-            if (target !== undefined && options.adapter.reached(room.locator, roomVersion, target)) {
-                wanted.delete(room.locator);
-            }
-            unreadable.delete(room.locator);
+            const set = await settle(local, room.locator, prior, confirmed, queue.filter((batch) => !accepted.includes(batch)), { room: true });
+            for (const batch of accepted)
+                pendings.delete(batch.id);
+            stale.delete(room.locator);
+            if (unreadable.delete(room.locator))
+                scopedRefusals.delete(room.locator);
             sourceRefusals.delete(room.locator);
             declarationRefusals.delete(room.locator);
             list(room, true);
             publishChangeSet(set);
             moveTo({ ...status, ...attention() });
+            return true;
         });
     }
     async function saveRoomDrafts(locator, named, writtenBy) {
@@ -726,7 +740,6 @@ export function composeRuntime(options) {
             operations: room.operations,
             providerOwnedPaths: room.providerOwnedPaths,
             providerLimits: limits,
-            rewriting: rewriting(),
             visible: replica.visible,
             changes: parts.flatMap(({ changes }) => changes),
             bases: parts.flatMap(({ bases }) => bases),
@@ -750,15 +763,16 @@ export function composeRuntime(options) {
             return { outcome: 'refused', rule: 'durable-write' };
         }
         pendings.set(built.batch.id, { drafts: saved, submission: { state: 'waiting' }, lost: false });
+        recorded = false;
         for (const path of consumed)
             forgetRoomDraft(locator, path);
-        replicas.set(locator, replicaOf(replica.confirmed, batches, rewriting(), replica));
+        replicas.set(locator, replicaOf(replica.confirmed, batches, replica));
         publishChangeSet(changeSet(locator, replica, replicas.get(locator) ?? null, {
             queue: true,
             drafts: consumed,
         }));
         moveTo({ ...saving(status), ...attention() });
-        void enqueue();
+        submitLater(locator);
         return { outcome: 'saved', identifier: built.batch.id };
     }
     async function mark(local, locator, identifier, submission, lost) {
@@ -823,10 +837,10 @@ export function composeRuntime(options) {
             return { kind: 'transport-uncertainty' };
         }
     }
-    function declaredCards() {
+    function declaredAgents() {
         for (const capability of capabilities) {
-            if (capability.conversationCards !== undefined)
-                return capability.conversationCards;
+            if (capability.conversationAgents !== undefined)
+                return capability.conversationAgents;
         }
         return undefined;
     }
@@ -857,8 +871,6 @@ export function composeRuntime(options) {
         journal.record(`transfer action ${name}`);
         try {
             const result = await options.adapter.action(authorization, { name, input });
-            if (result.kind === 'action' && result.at !== undefined)
-                want(result.at);
             if (result.kind === 'scoped-refusal') {
                 const room = replicas.get(result.locator)?.confirmed.record;
                 if (room !== undefined)
@@ -890,32 +902,11 @@ export function composeRuntime(options) {
             options.adapter.reached(locator, written, roomVersion) &&
             !options.adapter.reached(locator, roomVersion, written));
     }
-    function want({ locator, roomVersion }) {
-        if (reachedBy(locator, roomVersion))
-            return;
-        const held = wanted.get(locator);
-        if (held === undefined || options.adapter.reached(locator, roomVersion, held)) {
-            wanted.set(locator, roomVersion);
-        }
-    }
-    function reachOf(locator) {
-        let target = wanted.get(locator);
-        const versions = (replicas.get(locator)?.queue ?? []).flatMap((batch) => {
-            const accepted = pendings.get(batch.id)?.accepted;
-            return accepted === undefined ? [] : [accepted];
-        });
-        for (const version of versions) {
-            if (target === undefined || options.adapter.reached(locator, version, target)) {
-                target = version;
-            }
-        }
-        return target === undefined || reachedBy(locator, target) ? undefined : target;
-    }
-    async function pullRefresh(authorized, confirmed, minPosition) {
+    async function pullRefresh(authorized, confirmed) {
         if (!continuing())
             return unconfirmed;
         try {
-            const result = await refreshRoom(options.adapter, authorized, confirmed, continuing, minPosition);
+            const result = await refreshRoom(options.adapter, authorized, confirmed, (models, held) => remodel(confirmed.record.locator, models, held), continuing);
             const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
             return result;
@@ -932,7 +923,7 @@ export function composeRuntime(options) {
             const result = await bootstrapRoom(options.adapter, authorized, room, {
                 collection: modelOf(room.locator),
                 selection: modelOf(room.locator, 'typed-selection'),
-            }, continuing);
+            }, (models, held) => remodel(room.locator, models, held), continuing);
             const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
             return result;
@@ -945,20 +936,28 @@ export function composeRuntime(options) {
     async function advance(room, local, authorized) {
         const held = replicas.get(room.locator);
         if (held !== undefined) {
-            const refreshed = await pullRefresh(authorized, held.confirmed, reachOf(room.locator));
+            const refreshed = await pullRefresh(authorized, held.confirmed);
             if (!continuing())
                 return unconfirmed;
             if (refreshed.kind === 'still-current') {
                 if (sourceRefusals.has(room.locator))
                     return unconfirmed;
+                stale.delete(room.locator);
                 if (unreadable.delete(room.locator)) {
+                    scopedRefusals.delete(room.locator);
                     list(room, true);
                     emitRooms();
                 }
                 return null;
             }
             if (refreshed.kind === 'advanced') {
-                await publish(local, room, refreshed.confirmed);
+                if (!(await publish(local, room, refreshed.confirmed, held.confirmed))) {
+                    const now = replicas.get(room.locator)?.confirmed.record.roomVersion;
+                    const reached = now !== undefined &&
+                        options.adapter.reached(room.locator, now, refreshed.confirmed.record.roomVersion);
+                    return reached ? null : advance(room, local, authorized);
+                }
+                await retainModel(local, room, 'collection', modelOf(room.locator));
                 return null;
             }
             if (refreshed.kind !== 'beyond-horizon')
@@ -973,7 +972,7 @@ export function composeRuntime(options) {
         return null;
     }
     async function withhold(withheld, room, local, progress) {
-        progress.complete = false;
+        stale.add(room.locator);
         if (withheld.kind === 'scoped-refusal') {
             await scoped(withheld, room, local);
         }
@@ -1020,44 +1019,30 @@ export function composeRuntime(options) {
             (accepted.author === undefined ? '' : ` author ${accepted.author}`) +
             (accepted.time === undefined ? '' : ` time ${accepted.time}`));
     }
-    async function recordAccepted(room, local, submitted, accepted) {
-        await exclusive(async () => {
-            if (!continuing())
-                return;
-            const current = replicas.get(room.locator);
-            if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
-                return;
-            }
-            const state = pendings.get(submitted.id);
-            if (state === undefined)
-                return;
-            await local.accept(room.locator, submitted.id, accepted.roomVersion);
-            pendings.set(submitted.id, { ...state, accepted: accepted.roomVersion });
-            logAccepted(room.locator, submitted, accepted);
-            emitQueue(room.locator);
-        });
-    }
-    async function commitAccept(room, local, submitted, accepted, base, overlay) {
+    async function adoptAccepted(room, local, submitted, accepted) {
         if (!continuing())
             return unconfirmed;
         const current = replicas.get(room.locator);
         if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
             return null;
         }
-        const remaining = current.queue.filter((batch) => batch.id !== submitted.id);
-        const retainedBase = readConfirmed({
-            ...base.record,
-            model: modelOf(room.locator),
-            selectionModel: modelOf(room.locator, 'typed-selection'),
-        }, base);
-        const applied = overlay && retainedBase.kind === 'staged'
-            ? applyReturned(retainedBase.confirmed, accepted.documents, accepted.revisions, accepted.removals, accepted.roomVersion)
-            : retainedBase;
-        if (applied.kind !== 'staged')
+        const held = current.confirmed.record.roomVersion;
+        logAccepted(room.locator, submitted, accepted);
+        const applied = options.adapter.reached(room.locator, held, accepted.roomVersion)
+            ? { kind: 'staged', confirmed: current.confirmed }
+            : applyReturned(current.confirmed, accepted.documents, accepted.revisions, accepted.removals, accepted.attachments, options.adapter.follows(room.locator, held, accepted.roomVersion)
+                ? accepted.roomVersion
+                : held, accepted.roomVersion);
+        if (applied.kind !== 'staged') {
+            const state = pendings.get(submitted.id);
+            await local.accept(room.locator, submitted.id, accepted.roomVersion);
+            if (state !== undefined)
+                pendings.set(submitted.id, { ...state, accepted: accepted.roomVersion });
+            emitQueue(room.locator);
             return applied;
-        const set = await settle(local, room.locator, current, applied.confirmed, remaining, {
-            room: true,
-        });
+        }
+        const set = 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);
@@ -1066,17 +1051,8 @@ export function composeRuntime(options) {
         moveTo({ ...status, ...attention() });
         return null;
     }
-    async function accepting(room, local, submitted, accepted, pulled, fresh) {
-        const roomVersion = pulled.record.roomVersion;
-        if (options.adapter.reached(room.locator, roomVersion, accepted.roomVersion)) {
-            return committed(room, local, submitted, accepted, pulled, roomVersion === accepted.roomVersion);
-        }
-        if (fresh && continuing())
-            await publish(local, room, pulled);
-        return false;
-    }
-    async function committed(room, local, submitted, accepted, base, overlay) {
-        const failed = await exclusive(() => commitAccept(room, local, submitted, accepted, base, overlay));
+    async function adopted(room, local, submitted, accepted) {
+        const failed = await exclusive(() => adoptAccepted(room, local, submitted, accepted));
         if (failed === null)
             return true;
         if (failed.kind === 'refused' && continuing())
@@ -1089,10 +1065,8 @@ export function composeRuntime(options) {
             const head = replica?.queue[0];
             if (replica === undefined || head === undefined)
                 return;
-            if (pendings.get(head.id)?.accepted !== undefined) {
-                progress.complete = false;
+            if (pendings.get(head.id)?.accepted !== undefined)
                 return;
-            }
             const state = pendings.get(head.id);
             const { submission, lost: earlier } = state ?? {
                 submission: { state: 'waiting' },
@@ -1120,6 +1094,7 @@ export function composeRuntime(options) {
                 return;
             }
             const opensBefore = openSignals;
+            const answered = awaitingAnswer(room.locator);
             try {
                 result = await options.adapter.mutate(authorized, {
                     locator: room.locator,
@@ -1128,11 +1103,14 @@ export function composeRuntime(options) {
                 }, (upload) => exclusive(() => keepUpload(local, room.locator, head.id, upload)));
             }
             catch {
+                answered();
                 progress.complete = false;
                 if (continuing())
                     progress.reachable = false;
                 return;
             }
+            if (result.kind !== 'accepted' || !continuing())
+                answered();
             if (!continuing())
                 return;
             if (result.kind === 'transport-uncertainty') {
@@ -1185,6 +1163,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;
             }
             if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
@@ -1211,95 +1190,33 @@ export function composeRuntime(options) {
                     return withhold(withheld, room, local, progress);
                 continue;
             }
-            await recordAccepted(room, local, head, result);
-            const from = replicas.get(room.locator)?.confirmed;
-            if (from === undefined)
-                return;
-            const pulled = await pullRefresh(authorized, from, reachOf(room.locator));
-            if (!continuing())
-                return;
-            if (pulled.kind === 'revoked-authorization') {
-                await refuse('revoked-authorization');
-                return;
-            }
-            if (pulled.kind === 'scoped-refusal') {
-                await scoped(pulled, room, local);
-                progress.complete = false;
-                return;
-            }
-            if (pulled.kind === 'still-current' || pulled.kind === 'advanced') {
-                const fresh = pulled.kind === 'advanced';
-                if (!(await accepting(room, local, head, result, fresh ? pulled.confirmed : from, fresh))) {
-                    progress.complete = false;
-                    return;
-                }
-                continue;
-            }
-            if (pulled.kind === 'beyond-horizon') {
-                const bootstrapped = await pullBootstrap(authorized, room);
-                if (!continuing())
-                    return;
-                if (bootstrapped.kind === 'revoked-authorization') {
-                    await refuse('revoked-authorization');
-                    return;
-                }
-                if (bootstrapped.kind === 'scoped-refusal') {
-                    await scoped(bootstrapped, room, local);
-                    progress.complete = false;
-                    return;
-                }
-                if (bootstrapped.kind === 'staged') {
-                    if (!(await accepting(room, local, head, result, bootstrapped.confirmed, true))) {
-                        progress.complete = false;
-                        return;
-                    }
-                    continue;
-                }
+            const kept = await adopted(room, local, head, result).finally(answered);
+            if (!kept) {
                 progress.complete = false;
-                if (bootstrapped.kind === 'transport-uncertainty') {
-                    progress.reachable = false;
-                }
-                else if (bootstrapped.kind === 'room-not-readable') {
-                    unreadable.add(room.locator);
-                    list(room, false);
-                    emitRooms();
-                }
-                else if (bootstrapped.kind === 'refused') {
-                    refusedSource(room, bootstrapped);
-                }
                 return;
             }
-            progress.complete = false;
-            if (pulled.kind === 'transport-uncertainty') {
-                progress.reachable = false;
-            }
-            else if (pulled.kind === 'room-not-readable') {
-                unreadable.add(room.locator);
-                list(room, false);
-                emitRooms();
-            }
-            else if (pulled.kind === 'retryable-refusal') {
-                journal.record(`refusal ${pulled.kind} ${pulled.code}`);
-            }
-            else if (pulled.kind === 'refused') {
-                refusedSource(room, pulled);
-            }
-            return;
         }
-        return;
+    }
+    function awaitingAnswer(locator) {
+        let release = () => { };
+        const awaited = new Promise((resolve) => {
+            release = resolve;
+        });
+        answering.set(locator, awaited);
+        return () => {
+            if (answering.get(locator) === awaited)
+                answering.delete(locator);
+            release();
+        };
     }
     async function retainModel(local, room, attached, next) {
         const key = modelKey(room.locator, attached);
-        if (next.status === 'unavailable')
-            modelEpoch.set(key, (modelEpoch.get(key) ?? 0) + 1);
-        const epoch = modelEpoch.get(key) ?? 0;
         const previous = modelOf(room.locator, attached);
         const heldBefore = replicas.get(room.locator)?.confirmed.record;
         if (JSON.stringify(previous) === JSON.stringify(next) &&
             (heldBefore === undefined ||
                 (JSON.stringify(heldBefore.operations) === JSON.stringify(room.operations) &&
                     JSON.stringify(heldBefore.replica) === JSON.stringify(room.replica) &&
-                    JSON.stringify(heldBefore.attachedModel) === JSON.stringify(room.attachedModel) &&
                     JSON.stringify(heldBefore.typedSelection) ===
                         JSON.stringify(room.typedSelection ?? null))))
             return;
@@ -1310,15 +1227,12 @@ export function composeRuntime(options) {
         await exclusive(async () => {
             if (!continuing())
                 return;
-            if (next.status !== 'unavailable' && epoch !== (modelEpoch.get(key) ?? 0))
-                return;
             const held = replicas.get(room.locator);
             if (held !== undefined) {
                 const declared = {
                     ...held.confirmed.record,
                     operations: room.operations,
                     replica: room.replica,
-                    attachedModel: room.attachedModel,
                     typedSelection: room.typedSelection ?? null,
                     ...(attached === 'collection' ? { model: next } : { selectionModel: next }),
                 };
@@ -1338,7 +1252,7 @@ export function composeRuntime(options) {
                     queue: held.queue,
                 });
                 if (read.kind === 'staged') {
-                    replicas.set(room.locator, replicaOf(read.confirmed, held.queue, rewriting(), held));
+                    replicas.set(room.locator, replicaOf(read.confirmed, held.queue, held));
                     if (declarationRefusals.delete(room.locator)) {
                         sourceRefusals.delete(room.locator);
                         unreadable.delete(room.locator);
@@ -1362,77 +1276,6 @@ export function composeRuntime(options) {
                 publishChangeSet(changeSet(room.locator, held, replicas.get(room.locator) ?? null, { room: true }));
         });
     }
-    async function acquireModel(local, room, authorized, selection) {
-        const attached = selection === null ? 'collection' : 'typed-selection';
-        const key = modelKey(room.locator, attached);
-        const declared = selection === null ? room.attachedModel : selection.attachedModel;
-        let previous = modelOf(room.locator, attached);
-        if (previous.status !== 'unavailable' &&
-            (declared === null || !sameModel(previous.snapshot, declared))) {
-            previous = { status: 'unavailable', reason: 'version-changed' };
-            await retainModel(local, room, attached, previous);
-            if (discoveryPaused)
-                return;
-        }
-        const epoch = modelEpoch.get(key) ?? 0;
-        let answer;
-        try {
-            answer = await options.adapter.model(authorized, selection === null
-                ? { locator: room.locator, attached: 'collection', model: declared }
-                : {
-                    locator: room.locator,
-                    attached: 'typed-selection',
-                    roots: selection.roots,
-                    model: declared,
-                });
-        }
-        catch {
-            answer = { kind: 'transport-uncertainty' };
-        }
-        if (discoveryPaused || epoch !== (modelEpoch.get(key) ?? 0))
-            return;
-        if (answer.kind === 'revoked-authorization') {
-            await refuse('revoked-authorization');
-            return;
-        }
-        if (answer.kind === 'transport-uncertainty') {
-            await retainModel(local, room, attached, cached(previous));
-            return;
-        }
-        if (answer.kind === 'model-unavailable') {
-            await retainModel(local, room, attached, {
-                status: 'unavailable',
-                reason: answer.reason,
-            });
-            return;
-        }
-        if (declared === null || !sameModel(answer.snapshot, declared)) {
-            await retainModel(local, room, attached, {
-                status: 'unavailable',
-                reason: 'version-changed',
-            });
-            return;
-        }
-        if (previous.status !== 'unavailable' &&
-            sameModel(previous.snapshot, answer.snapshot) &&
-            previous.snapshot.schema !== answer.snapshot.schema) {
-            await retainModel(local, room, attached, { status: 'unavailable', reason: 'invalid' });
-            return;
-        }
-        const verified = answer.snapshot.schema === null ? EMPTY_SCHEMA : verify(answer.snapshot.schema);
-        if (verified.verdict === 'refuse') {
-            const where = verified.location === undefined ? '' : ` ${verified.location}`;
-            journal.record(`model invalid ${room.locator} ${attached} ${answer.snapshot.identity} ${verified.rule}${where}`);
-        }
-        await retainModel(local, room, attached, verified.verdict === 'accept'
-            ? {
-                status: 'current',
-                snapshot: structuredClone(answer.snapshot),
-                verifiedWith: MD_MODEL,
-                types: verified.model.types,
-            }
-            : { status: 'unavailable', reason: 'invalid' });
-    }
     async function scoped(result, room, local) {
         scopedRefusals.set(room.locator, { code: result.code, fields: result.fields });
         let scopedAway = room;
@@ -1460,14 +1303,34 @@ export function composeRuntime(options) {
         emitRooms();
         journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
     }
-    async function synchronize(discovered, local, progress) {
-        const prepared = await Promise.allSettled(discovered.map((room) => prepareRoom(room, local, progress)));
-        const ready = discovered.filter((_, index) => {
+    function heldRooms(listed) {
+        return listed.flatMap((room) => {
+            const record = replicas.get(room.locator)?.confirmed.record;
+            if (record === undefined || record.replica.selection !== room.replica.selection)
+                return [];
+            return [
+                {
+                    locator: room.locator,
+                    roomVersion: record.roomVersion,
+                    documents: record.documents,
+                    revisions: record.revisions,
+                    attachments: record.attachments,
+                },
+            ];
+        });
+    }
+    async function synchronize(listed, local, progress, attempt) {
+        const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(room, local, progress)));
+        const ready = listed.filter((_, index) => {
             const outcome = prepared[index];
             return outcome?.status === 'fulfilled' && outcome.value;
         });
-        const rooms = await Promise.allSettled(ready.map((room) => synchronizeRoom(room, local, progress)));
-        const failed = [...prepared, ...rooms].find((room) => room.status === 'rejected');
+        if (attempt === 'opened')
+            options.adapter.roomStream?.hold(heldRooms(ready));
+        const loaded = await Promise.allSettled(ready
+            .filter((room) => attempt === 'unstreamed' || !replicas.has(room.locator))
+            .map((room) => loadRoom(room, local, progress)));
+        const failed = [...prepared, ...loaded].find((room) => room.status === 'rejected');
         if (failed !== undefined)
             throw failed.reason;
     }
@@ -1484,11 +1347,8 @@ export function composeRuntime(options) {
             progress.complete = false;
             return false;
         }
-        const selection = room.typedSelection;
-        await Promise.all([
-            acquireModel(local, room, authorization, null),
-            ...(selection === undefined ? [] : [acquireModel(local, room, authorization, selection)]),
-        ]);
+        if (prior !== undefined)
+            await retainModel(local, room, 'collection', modelOf(room.locator));
         if (discoveryPaused || authorization === undefined)
             return false;
         if (room.replica.admission !== 'admitted') {
@@ -1496,24 +1356,53 @@ export function composeRuntime(options) {
                 progress.complete = false;
             return false;
         }
-        const held = replicas.get(room.locator);
-        if (held !== undefined && held.confirmed.record.replica.selection !== room.replica.selection) {
-            progress.complete = false;
-            return false;
-        }
         return true;
     }
-    async function synchronizeRoom(room, local, progress) {
+    async function caughtUp(room, local, progress) {
+        const held = replicas.get(room.locator)?.confirmed.record.roomVersion;
+        if (held === undefined || authorization === undefined)
+            return;
+        const behind = [announced.get(room.locator), room.roomVersion].some((later) => later !== undefined && !options.adapter.reached(room.locator, held, later));
+        if (!behind)
+            return;
+        const withheld = await advance(room, local, authorization);
+        if (withheld !== null)
+            await withhold(withheld, room, local, progress);
+    }
+    function revoked(locator) {
+        return ['collection', 'typed-selection'].some((attached) => {
+            const model = modelOf(locator, attached);
+            return model.status === 'unavailable' && model.reason === 'revoked';
+        });
+    }
+    async function loadRoom(room, local, progress) {
         if (discoveryPaused || authorization === undefined)
             return;
+        if (replicas.has(room.locator) && revoked(room.locator)) {
+            await reload(room, local, progress);
+            return;
+        }
         const withheld = await advance(room, local, authorization);
         if (withheld !== null) {
             await withhold(withheld, room, local, progress);
             return;
         }
-        await submitRoom(room, local, authorization, progress);
+        await caughtUp(room, local, progress);
     }
-    async function cycle(local, progress) {
+    async function reload(room, local, progress) {
+        if (discoveryPaused || authorization === undefined)
+            return;
+        const bootstrapped = await pullBootstrap(authorization, room);
+        if (!continuing())
+            return;
+        if (bootstrapped.kind !== 'staged') {
+            await withhold(bootstrapped, room, local, progress);
+            return;
+        }
+        await publish(local, room, bootstrapped.confirmed);
+        await caughtUp(room, local, progress);
+    }
+    async function discoverRooms(local, progress, attempt) {
         if (closed || authorization === undefined) {
             notifyReady();
             return;
@@ -1539,6 +1428,10 @@ export function composeRuntime(options) {
                 }
             }
             progress.reachable = false;
+            progress.complete = false;
+            if (attempt === 'opened') {
+                options.adapter.roomStream?.hold(heldRooms([...discovered.values()]));
+            }
             notifyReady();
             return;
         }
@@ -1553,17 +1446,6 @@ export function composeRuntime(options) {
             notifyReady();
             return;
         }
-        if (!result.supportedVersions.includes(ROOM_CONTRACT_VERSION)) {
-            await refuse('no-matching-version');
-            notifyReady();
-            return;
-        }
-        if (result.mdModel.identity !== MD_MODEL.identity ||
-            result.mdModel.version !== MD_MODEL.version) {
-            await refuse('md-model-version-mismatch');
-            notifyReady();
-            return;
-        }
         for (const room of result.rooms) {
             if (room.operations === undefined ||
                 !['read', 'sync', 'write', 'delete'].every((operation) => Array.isArray(room.operations[operation]) &&
@@ -1571,8 +1453,7 @@ export function composeRuntime(options) {
                 room.replica === undefined ||
                 typeof room.replica.selection !== 'string' ||
                 room.replica.selection.length === 0 ||
-                !['admitted', 'unavailable'].includes(room.replica.admission) ||
-                !declaredIdentity(room.attachedModel)) {
+                !['admitted', 'unavailable'].includes(room.replica.admission)) {
                 journal.record(`invalid model or replica declaration ${room.locator}`);
                 await refuse('missing-required-guarantee');
                 notifyReady();
@@ -1585,14 +1466,6 @@ export function composeRuntime(options) {
                 return;
             }
         }
-        const declared = new Set(result.capabilities.map((capability) => capability.name));
-        for (const required of options.requiredGuarantees) {
-            if (!knownCapabilities.has(required) || !declared.has(required)) {
-                await refuse('missing-required-guarantee');
-                notifyReady();
-                return;
-            }
-        }
         if (refusal !== null) {
             refusal = null;
             emitRefusal();
@@ -1600,26 +1473,13 @@ export function composeRuntime(options) {
         const previousCapabilities = capabilities;
         capabilities = result.capabilities;
         notifyReady();
-        if (declared.has('room-version-notifications'))
-            observeRoomVersions();
         if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits) ||
             JSON.stringify(result.capabilities) !== JSON.stringify(previousCapabilities)) {
             limits = result.providerLimits;
             await local.declare(limits, capabilities);
         }
         await applyDiscovery(result.rooms, local);
-        handSelected(result.rooms
-            .filter((room) => room.replica.admission === 'admitted')
-            .map((room) => room.locator)
-            .sort());
-        progress.complete = true;
-        await synchronize(result.rooms, local, progress);
-        if (closed || discoveryPaused)
-            return;
-        await conversations.reconcile();
-        if (status.providerUnreachable)
-            conversations.reconnected();
-        await conversations.catchUp(progress);
+        await synchronize(result.rooms, local, progress, attempt);
     }
     async function ensureAuthorization() {
         if (authorization !== undefined)
@@ -1633,64 +1493,246 @@ export function composeRuntime(options) {
             throw error;
         }
     }
-    async function connect() {
-        if (closed || stopping || discoveryPaused) {
-            notifyReady();
+    function task(work) {
+        if (stopping)
+            return chain;
+        chain = chain.then(work, work).catch(() => undefined);
+        return chain;
+    }
+    function sync(attempt) {
+        return task(async () => {
+            if (closed || stopping || discoveryPaused) {
+                notifyReady();
+                return;
+            }
+            const progress = { complete: true, reachable: true };
+            underway = attempt === 'opened' ? progress : null;
+            complete = false;
+            recorded = false;
+            moveTo(transferring(status));
+            try {
+                const local = await openLocal();
+                if (closed)
+                    return;
+                await ensureAuthorization();
+                if (closed)
+                    return;
+                await discoverRooms(local, progress, attempt);
+            }
+            catch {
+                progress.complete = false;
+                if (attempt === 'opened') {
+                    options.adapter.roomStream?.hold(heldRooms([...discovered.values()]));
+                }
+            }
+            finally {
+                notifyReady();
+            }
+            if (attempt === 'opened')
+                return;
+            await finishOpening(progress);
+        });
+    }
+    function closedSocket(revoked) {
+        const opened = socketOpen;
+        socketOpen = false;
+        if (revoked) {
+            void refuse('revoked-authorization');
             return;
         }
-        startTimer();
-        const progress = { complete: false, reachable: true };
-        let completedAt = new Date().toISOString();
-        try {
-            const local = await openLocal();
-            if (closed)
-                return;
-            await ensureAuthorization();
-            if (closed)
+        if (opened || status.providerUnreachable)
+            return;
+        moveTo({ ...status, providerUnreachable: true });
+    }
+    function applyOpening(expired) {
+        return task(async () => {
+            const progress = underway;
+            underway = null;
+            if (closed || stopping)
                 return;
-            await cycle(local, progress);
-            if (closed)
+            if (progress === null) {
+                await reloadExpired(expired);
                 return;
-            if (progress.complete) {
-                completedAt = new Date().toISOString();
-                await local.complete(completedAt);
             }
+            try {
+                const local = await openLocal();
+                const held = [...discovered.values()].filter((room) => replicas.has(room.locator));
+                const reloading = held.filter((room) => expired.includes(room.locator) || revoked(room.locator));
+                const reloaded = await Promise.allSettled(reloading.map((room) => reload(room, local, progress)));
+                if (progress.reachable) {
+                    for (const room of held)
+                        if (!reloading.includes(room))
+                            await confirmModels(room, local);
+                }
+                const failed = reloaded.find((outcome) => outcome.status === 'rejected');
+                if (failed !== undefined)
+                    throw failed.reason;
+            }
+            catch {
+                progress.complete = false;
+                progress.reachable = false;
+            }
+            await finishOpening(progress);
+        });
+    }
+    async function reloadExpired(expired) {
+        const progress = { complete: true, reachable: true };
+        try {
+            const local = await openLocal();
+            await Promise.allSettled([...discovered.values()]
+                .filter((room) => replicas.has(room.locator) && expired.includes(room.locator))
+                .map((room) => reload(room, local, progress)));
         }
         catch {
-            progress.complete = false;
-            notifyReady();
+            progress.reachable = false;
+        }
+        await rest(progress);
+    }
+    async function confirmModels(room, local) {
+        for (const attached of ['collection', 'typed-selection']) {
+            const model = modelOf(room.locator, attached);
+            if (model.status === 'cached') {
+                await retainModel(local, room, attached, { ...model, status: 'current' });
+            }
+        }
+    }
+    function submitLater(locator) {
+        const running = submitting.get(locator);
+        if (running !== undefined) {
+            running.again = true;
             return;
         }
-        finally {
-            notifyReady();
-            moveTo(settled(status, progress, completedAt, pending(), attention()));
+        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);
+            }
+        })();
+    }
+    function submitAll() {
+        for (const [locator, replica] of replicas) {
+            if (replica.queue.length > 0)
+                submitLater(locator);
         }
     }
-    async function run() {
+    async function finishOpening(progress) {
         try {
-            await connect();
+            if (closed || discoveryPaused) {
+                progress.complete = false;
+                return;
+            }
+            submitAll();
+            await conversations.reconcile();
+            if (status.providerUnreachable)
+                conversations.reconnected();
+            const reading = { complete: true, reachable: true };
+            await conversations.catchUp(reading);
+            if (!reading.reachable)
+                progress.reachable = false;
+        }
+        catch {
+            progress.complete = false;
         }
         finally {
-            inflight = false;
-            if (queued && !closed) {
-                queued = false;
-                void enqueue();
-            }
+            complete = progress.complete;
+            await rest(progress);
         }
     }
-    function observeRoomVersions() {
-        const path = options.adapter.roomVersions;
-        if (path === undefined || withdrawNotifications !== undefined)
+    async function rest(progress) {
+        if (closed)
             return;
-        withdrawNotifications = path.observe((notification) => {
-            if (closed || stopping || discoveryPaused)
+        let lastCompleted = status.lastCompleted;
+        let synced = complete && stale.size === 0 && !pending();
+        if (synced && !recorded) {
+            const completedAt = new Date().toISOString();
+            try {
+                await (await openLocal()).complete(completedAt);
+                recorded = true;
+                lastCompleted = completedAt;
+            }
+            catch {
+                synced = false;
+            }
+        }
+        moveTo({
+            state: pending() ? 'pending' : synced ? 'synced' : 'syncing',
+            lastCompleted,
+            providerUnreachable: !progress.reachable,
+            ...attention(),
+        });
+    }
+    function applyRoom(locator, roomVersion) {
+        announced.set(locator, roomVersion);
+        return task(async () => {
+            await answering.get(locator);
+            if (closed || stopping || discoveryPaused || authorization === undefined)
+                return;
+            const room = discovered.get(locator);
+            const held = replicas.get(locator);
+            if (room === undefined || room.replica.admission !== 'admitted')
                 return;
-            if (notification.modelChanged === true && handed?.includes(notification.locator) === true) {
-                void enqueue();
+            if (held !== undefined &&
+                (held.confirmed.record.replica.selection !== room.replica.selection ||
+                    options.adapter.reached(locator, held.confirmed.record.roomVersion, roomVersion))) {
+                return;
+            }
+            const during = underway;
+            const progress = during ?? { complete: true, reachable: true };
+            if (during === null)
+                moveTo(transferring(status));
+            try {
+                const local = await openLocal();
+                const withheld = await advance(room, local, authorization);
+                if (withheld !== null)
+                    await withhold(withheld, room, local, progress);
+            }
+            catch {
+                stale.add(locator);
+            }
+            finally {
+                if (during === null)
+                    await rest(progress);
+            }
+        });
+    }
+    function observeStream() {
+        const stream = options.adapter.roomStream;
+        if (stream === undefined || withdrawStream !== undefined)
+            return;
+        withdrawStream = stream.observe((event) => {
+            if (closed || stopping)
                 return;
+            if (event.kind === 'opened') {
+                socketOpen = true;
+                void sync('opened');
             }
-            notices.set(notification.locator, notification.roomVersion);
-            chain = chain.then(runNotified, runNotified);
+            else if (event.kind === 'closed')
+                closedSocket(event.revoked);
+            else if (event.kind === 'opening')
+                void applyOpening(event.expired);
+            else
+                void applyRoom(event.locator, event.roomVersion);
         });
     }
     function writesHeld() {
@@ -1711,14 +1753,17 @@ export function composeRuntime(options) {
                 listener(mode);
         }
         if (releasing)
-            void enqueue();
+            submitAll();
     }
     function observeConversations() {
         const stream = options.adapter.conversations;
         if (stream === undefined || withdrawConversations !== undefined)
             return;
         withdrawConversations = stream.observe((event) => {
-            conversations.receive(event);
+            if (conversations.receive(event)) {
+                void ready.then(scheduleCurrency);
+                return;
+            }
             if (event.kind !== 'gap' || conversations.current())
                 return;
             show();
@@ -1729,7 +1774,7 @@ export function composeRuntime(options) {
         if (currencyQueued || closed || stopping)
             return;
         currencyQueued = true;
-        chain = chain.then(runCurrency, runCurrency);
+        void task(runCurrency);
     }
     async function runCurrency() {
         currencyQueued = false;
@@ -1755,95 +1800,12 @@ export function composeRuntime(options) {
             }
         }
     }
-    function handSelected(locators) {
-        const path = options.adapter.roomVersions;
-        if (path === undefined || withdrawNotifications === undefined)
-            return;
-        if (handed !== undefined && JSON.stringify(locators) === JSON.stringify(handed))
-            return;
-        handed = locators;
-        path.select(locators);
-    }
-    async function runNotified() {
-        const announced = [...notices];
-        notices.clear();
-        if (announced.length === 0 || closed || stopping || discoveryPaused)
-            return;
-        const resting = status;
-        const progress = { complete: false, reachable: !resting.providerUnreachable };
-        moveTo(transferring(resting));
-        try {
-            const local = await openLocal();
-            for (const [locator, roomVersion] of announced) {
-                if (closed || discoveryPaused || authorization === undefined)
-                    return;
-                if (handed?.includes(locator) !== true)
-                    continue;
-                const room = discovered.get(locator);
-                const held = replicas.get(locator);
-                if (room === undefined)
-                    continue;
-                if (sourceRefusals.has(locator)) {
-                    void enqueue();
-                    continue;
-                }
-                if (held === undefined)
-                    continue;
-                if (held.confirmed.record.roomVersion === roomVersion)
-                    continue;
-                const withheld = await advance(room, local, authorization);
-                if (withheld === null)
-                    continue;
-                if (withheld.kind === 'refused') {
-                    void enqueue();
-                    continue;
-                }
-                if (withheld.kind === 'scoped-refusal') {
-                    await scoped(withheld, room, local);
-                    continue;
-                }
-                if (withheld.kind === 'transport-uncertainty') {
-                    progress.reachable = false;
-                    continue;
-                }
-                if (withheld.kind === 'room-not-readable') {
-                    unreadable.add(locator);
-                    list(room, false);
-                    emitRooms();
-                    continue;
-                }
-                if (withheld.kind === 'revoked-authorization') {
-                    await refuse('revoked-authorization');
-                    return;
-                }
-            }
-        }
-        catch {
-            progress.reachable = false;
-        }
-        finally {
-            if (!closed) {
-                moveTo(settled(resting, progress, resting.lastCompleted, pending(), attention()));
-            }
-        }
-    }
-    function enqueue() {
-        if (stopping)
-            return chain;
-        if (inflight) {
-            queued = true;
-            return chain;
-        }
-        inflight = true;
-        chain = chain.then(run, run);
-        return chain;
-    }
     function close() {
         if (closed)
             return;
         closed = true;
-        withdrawNotifications?.();
-        withdrawNotifications = undefined;
+        withdrawStream?.();
+        withdrawStream = undefined;
         withdrawConversations?.();
         withdrawConversations = undefined;
         withdrawServiceMode?.();
@@ -1867,6 +1829,7 @@ export function composeRuntime(options) {
         stopping = true;
         stopTimer();
         await chain.catch(() => undefined);
+        await Promise.all([...submitting.values()].map((run) => run.done));
         await mutations;
         close();
     }
@@ -1875,11 +1838,29 @@ export function composeRuntime(options) {
     options.signal?.addEventListener('abort', close, { once: true });
     if (options.signal?.aborted)
         close();
-    void openLocal().catch(() => {
+    observeStream();
+    void openLocal().then(() => {
+        if (capabilities.length > 0)
+            notifyReady();
+    }, () => {
         notifyReady();
     });
-    void enqueue();
-    function watch(topic, input, deliver) {
+    if (options.adapter.roomStream === undefined)
+        void sync('unstreamed');
+    function planned(input, reach) {
+        return planOf(input, roomFacts(reach), planReach(reach));
+    }
+    function watchPlan(plan, deliver) {
+        return readSide.watch(plan, identityOf(plan), deliver);
+    }
+    async function searched(input, reach) {
+        const plan = searchPlanOf(input);
+        const selected = plan.documents === undefined && reach === null
+            ? null
+            : (await readSide.query(filterOf(plan.documents ?? {}, roomFacts(reach), planReach(reach)))).documents;
+        return searchIndex.search(reach === null || reach.conversations ? plan : { ...plan, conversations: [] }, selected);
+    }
+    const watch = (topic, input, deliver) => {
         if (topic === 'room-drafts') {
             const listener = { notify: deliver, ready: false };
             roomDraftListeners.add(listener);
@@ -1900,6 +1881,8 @@ export function composeRuntime(options) {
         if (topic === 'conversation') {
             return conversations.watch(input[0], input[1], deliver);
         }
+        if (topic === 'conversations')
+            return conversations.watchList(deliver);
         if (topic === 'presentation') {
             const listener = {
                 app: input[0],
@@ -1962,9 +1945,8 @@ export function composeRuntime(options) {
                 queueSubscriptions.delete(queue);
             };
         }
-        const plan = planOf(input[0], roomFacts());
-        return readSide.watch(plan, identityOf(plan), deliver);
-    }
+        return watchPlan(planned(input[0], null), deliver);
+    };
     const md = {
         loaded() {
             return openLocal().then(() => undefined);
@@ -1972,15 +1954,8 @@ export function composeRuntime(options) {
         rooms() {
             return listed();
         },
-        query: ((input) => readSide.query(planOf(input, roomFacts()))),
-        async search(input) {
-            const plan = searchPlanOf(input);
-            const selected = plan.documents === undefined
-                ? null
-                : (await readSide.query(filterOf(plan.documents, roomFacts())))
-                    .documents;
-            return searchIndex.search(plan, selected);
-        },
+        query: ((input) => readSide.query(planned(input, null))),
+        search: (input) => searched(input, null),
         types(locator) {
             return {
                 collection: modelTypes(modelOf(locator)),
@@ -2087,9 +2062,7 @@ export function composeRuntime(options) {
         persistence() {
             return options.shell.persistentStorage;
         },
-        observe: ((topic, ...input) => opened((deliver) => watch(topic, input, (message) => {
-            deliver(structuredClone(message));
-        }), topic === 'query')),
+        observe: observing(watch),
         async reauthorize() {
             if (refusal === null || !refusal.reauthorizationOffered)
                 return;
@@ -2098,8 +2071,19 @@ export function composeRuntime(options) {
             await mutations;
             authorization = undefined;
             discoveryPaused = false;
-            await enqueue();
+            if (options.adapter.roomStream === undefined)
+                await sync('unstreamed');
+            else
+                await task(ensureAuthorization);
         },
     };
-    return { md, stop, watch };
+    const reachable = {
+        md,
+        watch,
+        plan: planned,
+        query: (plan) => readSide.query(plan),
+        watchPlan,
+        search: searched,
+    };
+    return { md, stop, watch, within: (reach) => narrowed(reachable, reach) };
 }