@agentshouse/mdruntime 0.1.0-c5d81e5d5cb58 → 0.1.0-c5fe3b2cddda7

package/dist/connection.js

@@ -8,11 +8,11 @@ import { seededResult } from './seed.js';
 import { documentKey, roomOfKey } from './rows.js';
 import { searchPlanOf } from './search.js';
 import { capped, MAXIMUM_WINDOW } from './windows.js';
-import { bootstrapRoom, NOTHING_DONE } from './bootstrap.js';
+import { bootstrapRoom } from './bootstrap.js';
 import { changeSet, mergeChangeSets } from './change-set.js';
 import { createConversationStore, } from './conversation.js';
 import { leaving as leavingIn, partnerOf, queuedFile, } from './change.js';
-import { available, collectionOf, composedOf, unreadable as unreadableIn, validRoot, } from './collection.js';
+import { available, collectionOf, composedOf, validRoot, } from './collection.js';
 import { runtimeError } from './failure.js';
 import { createLog } from './log.js';
 import { binaryRecord } from './binary.js';
@@ -20,11 +20,10 @@ import { attachedFile } from './file.js';
 import { openedFiles } from './opened.js';
 import { ABSENT_TARGET, absentBinary, attachAnswer, binaryAnswer, binaryLinkAnswer, calledResult, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, OFFLINE, undeclared, UNCERTAIN, UNREADABLE, } from './outcome.js';
 import { createRecovery } from './recovery.js';
-import { doorReads } from './reads.js';
 import { advancement } from './refresh.js';
 import { buildBatch, buildMove, joined, limiting, queuedDocuments, requeuing, } from './save.js';
-import { compositionOf, entryAt, landed, movedBy, overlayOf, replaying, returning, returnedPaths, sameMembership, slicing, slicingWith, standing, storedRecord, touchedBy, } from './replica.js';
-import { binaryBase, changedParts, changesOf, gatheredParts, held, heldFile, joinedDraft, moveTarget, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
+import { compositionOf, entryAt, landed, movedBy, overlayOf, replaying, returning, returnedPaths, slicing, slicingWith, standing, storedRecord, touchedBy, } from './replica.js';
+import { binaryBase, changedParts, changesOf, gatheredParts, held, heldFile, joinedDraft, moveTarget, readParts, readSavedParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
 import { same, saving, STARTING, transferring, } from './status.js';
 import { detectStorageLoss, nextGeneration, refusedForSpace, } from './durability.js';
 import { readinessOf, } from './readiness.js';
@@ -34,7 +33,7 @@ import { paced, ROW_WEIGHT, stepped, yielded } from './turn.js';
 import { identityTime, roomDraftRevision } from './identity.js';
 import { ancestors, beneath, normalize } from './paths.js';
 import { openRuntimeStore, } from './store.js';
-import { changedCleanly, sameComposition, validatedCollection, } from './validation.js';
+import { validatedNeighbourhood } from './validation.js';
 import { unconfirmed } from './transfer.js';
 import { governs, holds, narrowed, planReach, } from './reach.js';
 function within(root, path) {
@@ -59,36 +58,33 @@ const DERIVE_BYTES = 1 << 23;
 const DERIVE_FLOOR = 1 << 18;
 // An index build aims at this much database work, so a Save, a query or the next part's progress waits behind at most one short build.
 const DERIVE_AIM_MS = 250;
-// A build past its floor of text stops after a second and a half of work, so a Room whose text costs ten times the usual still reports progress within the 2 s bound.
+// A build past its floor of text stops after a second and a half of work, its full-text writes included, so a Room whose text costs ten times the usual holds a Save, a query or the next part's progress behind no longer build.
 const DERIVE_LONGEST_MS = 1_500;
-const WALK_BYTES = 1 << 20;
 const QUERY_BYTES = 1 << 20;
 const STAGE_BYTES = 1 << 20;
 const STAGE_FLOOR = 1 << 16;
 // A batch aims at this much database work, so a Save or a query waits behind at most one short write.
 const STAGE_AIM_MS = 50;
-const PARTS_HELD = 4;
-const QUEUED_BYTES = 1 << 23;
-// Bytes still arriving are reported at most this often, well inside the 2 s progress bound, so readiness is not rebuilt for every chunk the network hands over.
+const STREAMS_HELD = 4;
+const NOTHING_HELD = { bytes: 0 };
+const QUEUED_TEXT = 1 << 23;
+// Bytes still arriving are reported at most this often, so readiness is not rebuilt for every chunk the network hands over while a slow link still moves the figure.
 const ARRIVAL_REPORT_MS = 250;
-const CLEAN_CHANGES = 2_000;
 // A Room that locks offline stays readable this long after the connection drops, so a laptop waking or changing network keeps working while a disconnected device locks soon after.
 const LOCK_GRACE_MS = 120_000;
 function operationOf(input) {
     const operation = input?.operation_id;
     return typeof operation === 'string' ? operation : null;
 }
-function abandonedOn(signal) {
-    return new Promise((resolve) => {
-        if (signal.aborted)
-            resolve(null);
-        else
-            signal.addEventListener('abort', () => resolve(null), { once: true });
+function readUntil(read, signal) {
+    if (signal.aborted)
+        return Promise.resolve({ kind: 'transport-uncertainty' });
+    return new Promise((resolve, reject) => {
+        const stop = () => resolve({ kind: 'transport-uncertainty' });
+        signal.addEventListener('abort', stop, { once: true });
+        read.then(resolve, reject).finally(() => signal.removeEventListener('abort', stop));
     });
 }
-function roomLane(locator) {
-    return `room ${locator}`;
-}
 function pendingKey(locator, id) {
     return `${locator}\u0000${id}`;
 }
@@ -123,11 +119,19 @@ export function composeRuntime(options) {
     const liveModels = new FencedMap(isFenced);
     const invalidModels = new Set();
     const discovered = new Map();
-    const reads = doorReads(options.adapter, (locator) => discovered.get(locator), () => generation);
+    let inFlight = new AbortController();
+    const refreshed = options.adapter.refresh?.bind(options.adapter);
+    const reads = {
+        bootstrap: (authorized, request) => readUntil(options.adapter.bootstrap(authorized, request), inFlight.signal),
+        ...(refreshed === undefined
+            ? {}
+            : {
+                refresh: (authorized, request) => readUntil(refreshed(authorized, request), inFlight.signal),
+            }),
+        reached: (locator, roomVersion, target) => options.adapter.reached(locator, roomVersion, target),
+    };
     let roomsListed = false;
     const scopedRefusals = new Map();
-    const sourceRefusals = new Map();
-    const declarationRefusals = new Set();
     function modelOf(locator) {
         return models.get(locator) ?? NO_MODEL;
     }
@@ -150,10 +154,10 @@ export function composeRuntime(options) {
     let closed = false;
     let stopping = false;
     let withdrawStream;
-    const announced = new Map();
     let underway = null;
     let streamed = null;
     let handed = false;
+    let naming = 0;
     const recovery = (options.recovery ?? createRecovery()).scope(ROOM_ATTEMPTS);
     const repairing = new Set();
     const calling = new Set();
@@ -165,11 +169,11 @@ export function composeRuntime(options) {
     const stale = new Set();
     let generation = 0;
     let discovering = null;
-    let opened = null;
-    const owed = new Set();
-    const reloadsDue = new Map();
+    const reloadsDue = new Set();
     const lanes = new Map();
-    let roomReads = { generation, free: ROOM_READS, waiting: [] };
+    const roomLanes = new Map();
+    let roomWork = 0;
+    const roomReads = { free: ROOM_READS, waiting: [] };
     const working = new Set();
     let mutations = Promise.resolve();
     let gathering = null;
@@ -218,17 +222,16 @@ export function composeRuntime(options) {
     let readinessQueued = false;
     const catching = new Set();
     const transfers = new FencedMap(isFenced);
-    const installs = new Map();
-    const keptParts = new Map();
+    const installs = new Set();
     const arrivals = new Map();
+    const streaming = new Set();
     const underived = new Map();
     const unindexed = new Map();
+    const startedOver = new Map();
     let arrivalReported = 0;
-    let onScreen = options.shell.onScreen;
-    const shownWaiters = [];
-    let partsFree = PARTS_HELD;
-    let queuedBytes = 0;
-    const partWaiters = [];
+    let streamsFree = STREAMS_HELD;
+    let queuedText = 0;
+    const installWaiters = [];
     const stageBudget = {
         bytes: STAGE_FLOOR * 4,
         floor: STAGE_FLOOR,
@@ -241,7 +244,7 @@ export function composeRuntime(options) {
         ceiling: DERIVE_BYTES,
         aim: DERIVE_AIM_MS,
     };
-    let installWrites = Promise.resolve();
+    const installTurns = { busy: false, ahead: 0, finishing: [], starting: [] };
     const conversations = createConversationStore({
         agents: declaredAgents,
         documents: (declaration, after) => rowsQuery(planOf({
@@ -369,7 +372,9 @@ export function composeRuntime(options) {
         }
         const file = parts.file === undefined
             ? undefined
-            : await heldFile(parts.file.blob, binaryBase(await visibleOf(room, [path]), path));
+            : await heldFile(parts.file.blob, parts.file.base === undefined
+                ? binaryBase(await visibleOf(room, [path]), path)
+                : parts.file.base);
         const record = {
             locator: room,
             path,
@@ -408,7 +413,7 @@ export function composeRuntime(options) {
         const changed = new Map();
         for (const room of [...replicas.keys(), ...queuesWithoutReplica.keys()]) {
             for (const { batch, state } of entriesOf(room)) {
-                if (state === 'accepted' || state === 'local')
+                if (state === 'local')
                     continue;
                 for (const { path } of batch.changes)
                     changed.set(`${room}\u0000${path}`, { room, path });
@@ -429,16 +434,9 @@ export function composeRuntime(options) {
                 returned: structuredClone(record.returned),
             });
         }
-        for (const [room, refusal] of sourceRefusals)
-            attentionRequired.push({ room, refusal: structuredClone(refusal) });
         attentionRequired.sort((left, right) => {
             if (left.room !== right.room)
                 return left.room < right.room ? -1 : 1;
-            if ('refusal' in left || 'refusal' in right) {
-                if ('refusal' in left && 'refusal' in right)
-                    return 0;
-                return 'refusal' in left ? -1 : 1;
-            }
             if (left.path !== right.path)
                 return left.path < right.path ? -1 : 1;
             return 0;
@@ -593,9 +591,6 @@ export function composeRuntime(options) {
         if (localSaves)
             return Object.freeze({ batch, state: 'local' });
         const state = pendings.get(pendingKey(locator, batch.id));
-        if (state?.accepted !== undefined) {
-            return Object.freeze({ batch, state: 'accepted', roomVersion: state.accepted });
-        }
         return Object.freeze({ batch, ...(state?.submission ?? { state: 'waiting' }) });
     }
     function entriesOf(locator) {
@@ -712,7 +707,7 @@ export function composeRuntime(options) {
             coverage.push({
                 room: locator,
                 generation: replica.record.transfer,
-                current: !(catching.has(locator) || owed.has(locator) || transfers.has(locator)),
+                current: !(catching.has(locator) || transfers.has(locator)),
             });
             read.push({ locator, key: replica.record.key });
             for (const batch of replica.queue)
@@ -739,8 +734,6 @@ export function composeRuntime(options) {
         return { listed: named.every((room) => replicas.has(room)), rooms: named };
     }
     function roomState(locator) {
-        if (sourceRefusals.has(locator))
-            return 'refused';
         const listedRoom = discovered.get(locator);
         if (roomsListed &&
             (listedRoom === undefined ||
@@ -770,80 +763,47 @@ export function composeRuntime(options) {
             ? 'connected'
             : 'connecting';
     }
-    function refusedIn(locators) {
-        return locators.flatMap((room) => {
-            const held = sourceRefusals.get(room);
-            if (held === undefined)
-                return [];
-            const { file, location } = held.fields;
-            return [
-                {
-                    room,
-                    name: discovered.get(room)?.name ?? room,
-                    file: typeof file === 'string' ? file : '',
-                    rule: held.code,
-                    location: typeof location === 'string' ? location : null,
-                },
-            ];
-        });
+    function bytesOf(room, underway) {
+        const transfer = transfers.get(room);
+        if (transfer !== undefined) {
+            const owed = (unindexed.get(room) ?? []).reduce((sum, part) => sum + part.bytes, 0);
+            return {
+                done: transfer.done.bytes - Math.ceil(owed),
+                total: Math.max(arrivals.get(room) ?? 0, transfer.done.bytes),
+            };
+        }
+        const held = underway ? NOTHING_HELD : (replicas.get(room)?.record.inventory ?? NOTHING_HELD);
+        return { done: held.bytes, total: arrivals.get(room) ?? held.bytes };
     }
     function installationOf(coverage) {
         const rooms = { done: 0, total: 0 };
-        const parts = { done: 0, total: 0 };
         const bytes = { done: 0, total: 0 };
-        const received = { done: 0, total: 0 };
         let installing = 0;
-        let unlisted = false;
-        let listed = false;
-        let waiting = false;
+        let downloading = false;
         for (const { room, state } of coverage) {
             if (state === 'unadmitted')
                 continue;
             rooms.total += 1;
             if (state === 'complete')
                 rooms.done += 1;
-            const transfer = transfers.get(room);
-            const replica = replicas.get(room)?.record.inventory ?? null;
-            const inventory = transfer?.inventory ?? replica ?? installs.get(room) ?? null;
             const underway = state === 'acquiring' || (installs.has(room) && state !== 'complete');
             if (underway)
                 installing += 1;
-            if (underway && inventory === null)
-                unlisted = true;
-            if (inventory !== null) {
-                listed = true;
-                const done = transfer?.done ?? (replica === null ? NOTHING_DONE : inventory);
-                const owed = (unindexed.get(room) ?? []).reduce((sum, part) => sum + part.bytes, 0);
-                parts.total += inventory.parts;
-                bytes.total += inventory.bytes;
-                parts.done += done.parts;
-                bytes.done += done.bytes - Math.ceil(owed);
-                received.total += inventory.bytes;
-                received.done += done.bytes;
-                for (const held of [keptParts.get(room), arrivals.get(room)]) {
-                    for (const arrived of held?.values() ?? [])
-                        received.done += arrived;
-                }
-            }
-            waiting ||= underway;
+            if (underway && (streaming.has(room) || !arrivals.has(room)))
+                downloading = true;
+            const now = bytesOf(room, underway);
+            const earlier = underway ? startedOver.get(room) : undefined;
+            bytes.done += Math.max(now.done, earlier?.done ?? 0);
+            bytes.total += Math.max(now.total, earlier?.total ?? 0);
         }
         const step = installing === 0
             ? null
-            : !listed
-                ? 'listing'
-                : unlisted || received.done < received.total
-                    ? 'downloading'
-                    : bytes.done < bytes.total
-                        ? 'writing'
-                        : 'replaying';
-        return {
-            step,
-            paused: waiting && !onScreen ? 'hidden' : null,
-            rooms,
-            parts,
-            bytes,
-            received,
-        };
+            : downloading
+                ? 'downloading'
+                : bytes.done < bytes.total
+                    ? 'writing'
+                    : 'replaying';
+        return { step, rooms, bytes };
     }
     function readinessFor(port, reach) {
         const required = requiredRooms(reach);
@@ -867,7 +827,6 @@ export function composeRuntime(options) {
             house: refusal !== null ? 'refused' : writesHeld() ? 'write-halted' : 'open',
             space: full ? 'full' : port.space,
             installation: installationOf(coverage),
-            refused: refusedIn(required.rooms),
             lost: storageLoss !== null,
             established: targets[port.target]?.established === true ||
                 (usableWhenHeld.includes(port.target) && required.rooms.some((room) => reopened.has(room))),
@@ -1104,6 +1063,8 @@ export function composeRuntime(options) {
     }
     async function refuse(reason, provider = null) {
         discoveryPaused = true;
+        inFlight.abort();
+        inFlight = new AbortController();
         try {
             if (reason === 'revoked-authorization') {
                 await exclusive(async () => {
@@ -1188,7 +1149,7 @@ export function composeRuntime(options) {
             providerOwnedPaths: room.providerOwnedPaths,
             roomVersion: replicas.get(room.locator)?.record.roomVersion ?? null,
             synchronizationAvailable,
-            refusal: scopedRefusals.get(room.locator) ?? sourceRefusals.get(room.locator) ?? null,
+            refusal: scopedRefusals.get(room.locator) ?? null,
         });
     }
     async function applyDiscovery(found, started, covered) {
@@ -1274,16 +1235,14 @@ export function composeRuntime(options) {
             roomDrafts.delete(locator);
             attachedFiles.delete(locator);
             untransferred(locator);
+            startedOver.delete(locator);
             catching.delete(locator);
             discovered.delete(locator);
-            announced.delete(locator);
             unreadable.delete(locator);
             stale.delete(locator);
             repairable.delete(locator);
             unpreparable.delete(locator);
             scopedRefusals.delete(locator);
-            sourceRefusals.delete(locator);
-            declarationRefusals.delete(locator);
             models.delete(locator);
             liveModels.delete(locator);
             invalidModels.delete(locator);
@@ -1372,16 +1331,9 @@ export function composeRuntime(options) {
         const queuedBatches = new Map(queues.map((queue) => [queue.locator, queue.pending.map(({ batch }) => batch)]));
         targets = held.targets;
         transfers.clear();
-        for (const [locator, record] of held.transfers) {
-            transfers.set(locator, {
-                ...record,
-                models: { collection: retyped(record.models.collection) },
-            });
-        }
         arrivals.clear();
-        keptParts.clear();
-        for (const [locator, parts] of held.kept)
-            keptParts.set(locator, new Map(parts));
+        streaming.clear();
+        startedOver.clear();
         limits = held.providerLimits;
         capabilities = held.capabilities;
         member = held.member;
@@ -1391,7 +1343,7 @@ export function composeRuntime(options) {
         presentations.clear();
         for (const record of held.presentation)
             presentations.set(record.app, record.value);
-        conversations.hydrate(heldConversations, chatDrafts);
+        conversations.hydrate(heldConversations, chatDrafts, held.conversationList);
         pendings.clear();
         for (const queue of queues) {
             for (const { batch, state } of queue.pending) {
@@ -1434,8 +1386,14 @@ export function composeRuntime(options) {
                 });
             }
         });
-        for (const key of held.orphans)
-            await opened.release(key);
+        try {
+            for (const key of held.orphans)
+                await opened.release(key);
+        }
+        catch (error) {
+            if (!refusedForSpace(error))
+                throw error;
+        }
         if (held.erasing || held.orphans.length > 0)
             queueMicrotask(sweep);
         return {
@@ -1637,8 +1595,6 @@ export function composeRuntime(options) {
     function unpairedIn(locator, batch) {
         if (!queueIn(locator).some((held) => held.id === batch.id))
             return false;
-        if (pendings.get(pendingKey(locator, batch.id))?.accepted !== undefined)
-            return false;
         return !leavingIn(batch, locator) || withdrawable(locator)(batch);
     }
     async function together(local, settlements) {
@@ -1807,28 +1763,34 @@ export function composeRuntime(options) {
         models.set(locator, state);
         return { collection: state };
     }
-    function publish(local, room, record, landing, live) {
+    function publish(local, room, reached, landing, live) {
         const landed = exclusive(async () => {
             if (!live()) {
                 caughtUpTo(room.locator);
                 return true;
             }
             const prior = replicas.get(room.locator);
-            if (landing.kind === 'refreshed' &&
-                (prior === undefined || prior.record.key !== record.key || prior.confirmed !== landing.base)) {
-                await local.unrefresh(record.key);
+            if (!stands(room.locator, landing.from)) {
+                if (landing.kind === 'refreshed') {
+                    await local.unrefresh(reached.key);
+                    return false;
+                }
+                caughtUpTo(room.locator);
+                await abandoned(local, room.locator);
                 return false;
             }
+            const record = landing.kind === 'refreshed' && prior !== undefined
+                ? {
+                    ...prior.record,
+                    roomVersion: reached.roomVersion,
+                    ...(landing.remodelled ? { model: reached.model } : {}),
+                }
+                : reached;
             adoptModels(room.locator, record);
             const queue = prior?.queue ?? queuesWithoutReplica.get(room.locator) ?? [];
-            const roomVersion = record.roomVersion;
-            const accepted = queue.filter((batch) => {
-                const at = pendings.get(pendingKey(room.locator, batch.id))?.accepted;
-                return at !== undefined && options.adapter.reached(room.locator, roomVersion, at);
-            });
             let set;
             try {
-                set = await settle(local, room.locator, prior, record, queue.filter((batch) => !accepted.includes(batch)), landing.kind === 'refreshed'
+                set = await settle(local, room.locator, prior, record, queue, landing.kind === 'refreshed'
                     ? {
                         room: true,
                         view: 'refreshed',
@@ -1851,23 +1813,21 @@ export function composeRuntime(options) {
             }
             if (landing.kind === 'bootstrapped') {
                 untransferred(room.locator);
+                startedOver.delete(room.locator);
                 catching.delete(room.locator);
-                sweep();
+                if (prior !== undefined && prior.record.key !== record.key)
+                    sweep();
+                name(room.locator);
             }
-            for (const batch of accepted)
-                pendings.delete(pendingKey(room.locator, batch.id));
             stale.delete(room.locator);
             unpreparable.delete(room.locator);
             if (unreadable.delete(room.locator))
                 scopedRefusals.delete(room.locator);
-            sourceRefusals.delete(room.locator);
-            declarationRefusals.delete(room.locator);
             list(room, true);
             publishChangeSet(set);
             await unpair(local);
             moveTo({ ...status, ...attention() });
-            options.adapter.roomStream?.published(room.locator, roomVersion);
-            if (accepted.length > 0 && (replicas.get(room.locator)?.queue.length ?? 0) > 0) {
+            if (landing.kind === 'bootstrapped' && (replicas.get(room.locator)?.queue.length ?? 0) > 0) {
                 submitLater(room.locator);
             }
             return true;
@@ -1897,12 +1857,7 @@ export function composeRuntime(options) {
         return committed(locator, target, saved, new Set(saved.map(({ path }) => path)), writtenBy);
     }
     async function saveParts(locator, named, writtenBy) {
-        const read = named.map(({ path, parts }) => ({ path, parts: readParts(parts) }));
-        if (read.some(({ path }, at) => path === '' ||
-            normalize(path) !== path ||
-            read.findIndex((one) => one.path === path) !== at)) {
-            throw runtimeError('room-draft-malformed');
-        }
+        const read = readSavedParts(named);
         const target = await savedRoom(locator);
         const saved = [];
         const files = [];
@@ -1911,7 +1866,7 @@ export function composeRuntime(options) {
         for (const { path, parts } of read) {
             const file = parts.file === undefined
                 ? undefined
-                : await heldFile(parts.file.blob, binaryBase(visible, path));
+                : await heldFile(parts.file.blob, parts.file.base === undefined ? binaryBase(visible, path) : parts.file.base);
             if (parts.file !== undefined && file !== undefined) {
                 files.push({ key: file.localId, blob: parts.file.blob });
             }
@@ -1976,18 +1931,6 @@ export function composeRuntime(options) {
             return undefined;
         return entry.binary !== null ? null : entry.content;
     }
-    function walkOf(local, key, view) {
-        return async (after) => {
-            const page = await local.walk(key, view, after, WALK_BYTES);
-            return {
-                entries: page.entries.map(({ path, content, binary }) => ({
-                    path,
-                    content: binary !== null ? null : content,
-                })),
-                next: page.next,
-            };
-        };
-    }
     function lookupOf(local, key, view) {
         return async (paths) => {
             if (paths.length === 0)
@@ -2004,37 +1947,6 @@ export function composeRuntime(options) {
         const read = parseFrontmatter(entry.content ?? '');
         return { type: read.ok ? (read.frontmatter.type ?? 'any') : undefined, binary: false };
     }
-    function overriddenWalk(walk, overrides) {
-        const sorted = [...overrides.keys()].sort();
-        const beyond = (path) => {
-            if (path === null)
-                return 0;
-            let low = 0;
-            let high = sorted.length;
-            while (low < high) {
-                const middle = (low + high) >>> 1;
-                if (sorted[middle] <= path)
-                    low = middle + 1;
-                else
-                    high = middle;
-            }
-            return low;
-        };
-        return async (after) => {
-            const page = await walk(after);
-            const end = page.next;
-            const added = sorted
-                .slice(beyond(after), end === null ? sorted.length : beyond(end))
-                .flatMap((path) => {
-                const entry = overrides.get(path);
-                return entry === null || entry === undefined
-                    ? []
-                    : [{ path, content: entry.binary !== null ? null : entry.content }];
-            });
-            const entries = [...page.entries.filter(({ path }) => !overrides.has(path)), ...added].sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
-            return { entries, next: end };
-        };
-    }
     function overriddenLookup(lookup, overrides) {
         return async (paths) => {
             const known = new Map(await lookup(paths.filter((path) => !overrides.has(path))));
@@ -2052,9 +1964,8 @@ export function composeRuntime(options) {
     }
     function validatorOf(record, confirmedLayer) {
         return async (resulting, touched) => {
-            const composition = compositionFor(record);
             const local = await openLocal();
-            const changed = [];
+            const changes = [];
             const overrides = new Map();
             const pace = paced();
             for (const path of new Set([...confirmedLayer.held, ...touched])) {
@@ -2065,19 +1976,13 @@ export function composeRuntime(options) {
                     continue;
                 overrides.set(path, now);
                 if (textOf(was) !== textOf(now))
-                    changed.push({ path, was: textOf(was), now: textOf(now) });
+                    changes.push({ path, was: textOf(was), now: textOf(now) });
             }
-            const lookup = overriddenLookup(lookupOf(local, record.key, 'confirmed'), overrides);
-            const clean = available(composition) &&
-                changed.length <= CLEAN_CHANGES &&
-                (await changedCleanly(changed, composed(record), composition, {
-                    lookup,
-                    texts: textsOf(local, record.key, 'confirmed'),
-                    referrers: referrersOf(local, record.key, 'confirmed'),
-                }));
-            if (clean)
-                return { verdict: 'accept' };
-            return validatedCollection(overriddenWalk(walkOf(local, record.key, 'confirmed'), overrides), lookup, composition);
+            return validatedNeighbourhood(changes, compositionFor(record), {
+                lookup: overriddenLookup(lookupOf(local, record.key, 'confirmed'), overrides),
+                texts: textsOf(local, record.key, 'confirmed'),
+                referrers: referrersOf(local, record.key, 'confirmed'),
+            });
         };
     }
     function textsOf(local, key, view) {
@@ -2154,7 +2059,7 @@ export function composeRuntime(options) {
         }
         const moves = saved.map(({ path, parts }) => ({ path, to: moveTarget(parts.move) }));
         const sourceSaving = await savingIn(replica, moves.map(({ path }) => ({ kind: 'remove', path })), saved.map(({ path }) => path), moves.map(({ path }) => path));
-        const changed = saved.flatMap(({ path, parts }) => changedParts(path, underneath(parts, path, sourceSaving.visible)));
+        const changed = saved.flatMap(({ path, parts }) => changedParts(path, parts, sourceSaving.visible));
         if (changed.length > 0)
             return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
         const target = replicas.get(destination);
@@ -2279,7 +2184,7 @@ export function composeRuntime(options) {
             ...saved.map(({ path }) => path),
             ...parts.flatMap(({ bases }) => bases.map(({ path }) => path)),
         ]);
-        const changed = saved.flatMap(({ path, parts: held }) => changedParts(path, underneath(held, path, saving.visible)));
+        const changed = saved.flatMap(({ path, parts: held }) => changedParts(path, held, saving.visible));
         if (changed.length > 0)
             return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
         const requeue = await stepped(requeuing(replica.queue, changes, saving.visible, withdrawable(locator), saving.visibleOver));
@@ -2852,115 +2757,16 @@ export function composeRuntime(options) {
             options.adapter.reached(locator, written, roomVersion) &&
             !options.adapter.reached(locator, roomVersion, written));
     }
-    function overriddenTexts(texts, overrides) {
-        return async (paths) => {
-            const known = new Map(await texts(paths.filter((path) => !overrides.has(path))));
-            for (const path of paths) {
-                const entry = overrides.get(path);
-                if (entry === undefined)
-                    continue;
-                if (entry === null)
-                    known.delete(path);
-                else
-                    known.set(path, entry.binary !== null ? null : entry.content);
-            }
-            return known;
-        };
-    }
-    async function unreadableRoom(texts, walk, paths) {
-        if (paths !== null) {
-            const text = {};
-            for (const [path, content] of await texts(paths))
-                if (content !== null)
-                    text[path] = content;
-            return stepped(unreadableIn(text, Object.keys(text)));
-        }
-        for (let after = null;;) {
-            const page = await walk(after);
-            const text = {};
-            for (const { path, content } of page.entries)
-                if (content !== null)
-                    text[path] = content;
-            const refused = await stepped(unreadableIn(text, Object.keys(text)));
-            if (refused !== null)
-                return refused;
-            if (page.next === null)
-                return null;
-            after = page.next;
-        }
-    }
-    async function validatedRoom(local, record, view, previous, overrides = null) {
-        const composition = composed(record);
-        const modeled = record.model.status !== 'unavailable' || record.typedSelection !== null;
-        const lookup = overrides === null
-            ? lookupOf(local, record.key, view)
-            : overriddenLookup(lookupOf(local, record.key, view), overrides);
-        const texts = overrides === null
-            ? textsOf(local, record.key, view)
-            : overriddenTexts(textsOf(local, record.key, view), overrides);
-        const walk = overrides === null
-            ? walkOf(local, record.key, view)
-            : overriddenWalk(walkOf(local, record.key, view), overrides);
-        let changes = null;
-        let reshaped = false;
-        if (previous !== null && previous.changed.length <= CLEAN_CHANGES) {
-            const [was, now] = await Promise.all([
-                local.entries(record.key, 'confirmed', previous.changed),
-                overrides === null
-                    ? local.entries(record.key, view, previous.changed)
-                    : Promise.resolve([]),
-            ]);
-            const before = new Map(was.map((entry) => [entry.path, entry]));
-            const after = overrides === null
-                ? new Map(now.map((entry) => [entry.path, entry]))
-                : overrides;
-            changes = previous.changed.flatMap((path) => {
-                const one = before.get(path) ?? null;
-                const other = after.get(path) ?? null;
-                reshaped ||= textDiffers(one, other);
-                const held = textOf(one);
-                const next = textOf(other);
-                return held === next ? [] : [{ path, was: held, now: next }];
-            });
-        }
-        const named = changes === null ? null : changes.map(({ path }) => path);
-        const textChanged = changes === null || changes.length > 0 || reshaped;
-        const modelsChanged = previous === null || !sameComposition(composed(previous.record), composition);
-        if (modeled && (textChanged || modelsChanged)) {
-            const clean = previous !== null &&
-                changes !== null &&
-                (await changedCleanly(changes, composed(previous.record), composition, {
-                    lookup,
-                    texts,
-                    referrers: referrersOf(local, record.key, 'confirmed'),
-                }));
-            if (clean)
-                return null;
-            const verdict = await validatedCollection(walk, lookup, composition);
-            if (verdict.verdict === 'accept')
-                return null;
-            if (verdict.rule !== 'model-unavailable')
-                return { kind: 'refused', refusal: verdict };
-            return unreadableRoom(texts, walk, named);
-        }
-        if (textChanged)
-            return unreadableRoom(texts, walk, named);
-        return null;
-    }
     function refreshingOf(local, key, composition, liveness, replaying = null) {
-        const write = replaying === null ? exclusive : installWrite;
+        const write = replaying === null ? exclusive : finishingWrite;
         return {
-            async turn() {
-                if (replaying === null)
-                    return;
-                installing(replaying);
-                await screened();
+            turn() {
+                if (replaying !== null)
+                    installing(replaying);
             },
             prior: async (paths) => new Map((await local.entries(key, 'refreshed', paths)).map((entry) => [entry.path, entry])),
             async stage(page) {
                 for (let written = 0;;) {
-                    if (replaying !== null)
-                        await screened();
                     const end = batchEnd(page.entries, written);
                     const last = end === page.entries.length;
                     const entries = page.entries.slice(written, end);
@@ -3005,25 +2811,74 @@ export function composeRuntime(options) {
         return done;
     }
     function installWrite(work) {
-        const next = installWrites.then(() => exclusive(work), () => exclusive(work));
-        installWrites = next.then(() => undefined, () => undefined);
-        return next;
-    }
-    function screened() {
-        if (onScreen || closed)
-            return Promise.resolve();
-        queueReadiness();
-        return new Promise((resolve) => shownWaiters.push(resolve));
+        return installTurn(installTurns.starting, work);
+    }
+    function finishingWrite(work) {
+        return installTurn(installTurns.finishing, work);
+    }
+    function installTurn(queue, work) {
+        return new Promise((resolve, reject) => {
+            queue.push(() => void exclusive(work)
+                .then(resolve, reject)
+                .finally(() => {
+                installTurns.busy = false;
+                nextInstallTurn();
+            }));
+            nextInstallTurn();
+        });
     }
-    async function heldPart() {
-        while (partsFree === 0 || queuedBytes >= QUEUED_BYTES) {
-            await new Promise((admit) => partWaiters.push(admit));
+    function nextInstallTurn() {
+        if (installTurns.busy || installTurns.ahead > 0)
+            return;
+        const turn = installTurns.finishing.shift() ?? installTurns.starting.shift();
+        if (turn === undefined)
+            return;
+        installTurns.busy = true;
+        turn();
+    }
+    async function ahead(work) {
+        let taken = false;
+        const hold = {
+            take() {
+                if (taken)
+                    return;
+                taken = true;
+                installTurns.ahead += 1;
+            },
+            release() {
+                if (!taken)
+                    return;
+                taken = false;
+                installTurns.ahead -= 1;
+                resumeInstall();
+            },
+        };
+        hold.take();
+        try {
+            return await work(hold);
         }
-        partsFree -= 1;
+        finally {
+            hold.release();
+        }
+    }
+    function resumeInstall() {
+        if (installTurns.ahead > 0)
+            return;
+        void yielded().then(nextInstallTurn);
+    }
+    async function heldStream() {
+        while (streamsFree === 0)
+            await new Promise((admit) => installWaiters.push(admit));
+        streamsFree -= 1;
         return once(() => {
-            partsFree += 1;
+            streamsFree += 1;
         });
     }
+    async function unqueued() {
+        while (queuedText >= QUEUED_TEXT) {
+            await new Promise((admit) => installWaiters.push(admit));
+        }
+    }
     function once(release) {
         let released = false;
         return () => {
@@ -3031,20 +2886,29 @@ export function composeRuntime(options) {
                 return;
             released = true;
             release();
-            for (const admit of partWaiters.splice(0))
+            for (const admit of installWaiters.splice(0))
                 admit();
         };
     }
-    function installing(locator, inventory = null) {
-        installs.set(locator, inventory ?? installs.get(locator) ?? null);
+    function installing(locator) {
+        installs.add(locator);
         queueReadiness();
     }
     function untransferred(locator) {
         transfers.delete(locator);
-        keptParts.delete(locator);
+        arrivals.delete(locator);
+        streaming.delete(locator);
         underived.delete(locator);
         unindexed.delete(locator);
     }
+    function setBack(locator) {
+        const now = bytesOf(locator, true);
+        const earlier = startedOver.get(locator);
+        startedOver.set(locator, {
+            done: Math.max(now.done, earlier?.done ?? 0),
+            total: Math.max(now.total, earlier?.total ?? 0),
+        });
+    }
     function owedIndexes(locator, bytes, text) {
         if (bytes <= 0 || text <= 0)
             return;
@@ -3074,41 +2938,34 @@ export function composeRuntime(options) {
         if (installs.delete(locator))
             queueReadiness();
     }
-    function screen(value) {
-        if (value === onScreen)
-            return;
-        onScreen = value;
-        journal.record(`installation ${value ? 'shown' : 'hidden'}`);
-        queueReadiness();
-        if (!value)
-            return;
-        for (const resolve of shownWaiters.splice(0))
-            resolve();
-    }
-    async function pullRefresh(authorized, held, liveness) {
+    async function pullRefresh(authorized, held, liveness, hold, refresh) {
         if (!liveness())
             return unconfirmed;
-        const turn = generation;
         const { record } = held;
-        const base = held.confirmed;
+        const from = standingOf(record.locator);
         const local = await openLocal();
         try {
             await exclusive(() => local.unrefresh(record.key));
-            const result = await advancement(reads, authorized, record, (models, kept) => (liveness() ? remodel(record.locator, models, kept) : kept), liveness, refreshingOf(local, record.key, composed(record), liveness));
+            const result = await advancement(async (authorization, request) => {
+                hold.release();
+                try {
+                    return await refresh(authorization, request);
+                }
+                finally {
+                    hold.take();
+                }
+            }, authorized, record, (models, kept) => (liveness() ? remodel(record.locator, models, kept) : kept), liveness, refreshingOf(local, record.key, composed(record), liveness));
             if (result.kind !== 'advanced') {
                 journal.record(`transfer refresh ${record.locator} ${result.kind}`);
                 return result;
             }
-            const refused = await validatedRoom(local, result.record, 'refreshed', {
-                record,
-                changed: [...result.changed],
-            });
-            if (refused !== null) {
-                journal.record(`transfer refresh ${record.locator} refused`);
-                return refused;
-            }
             journal.record(`transfer refresh ${record.locator} ${result.record.roomVersion}`);
-            return { kind: 'advanced', record: result.record, base };
+            return {
+                kind: 'advanced',
+                record: result.record,
+                from,
+                remodelled: result.record.model !== record.model,
+            };
         }
         catch (error) {
             if (refusedForSpace(error))
@@ -3116,9 +2973,6 @@ export function composeRuntime(options) {
             journal.record(`transfer refresh ${record.locator} transport-uncertainty`);
             throw error;
         }
-        finally {
-            reads.finished(record.locator, turn);
-        }
     }
     const heldContents = new Map();
     function heldContentOf(local, key) {
@@ -3136,24 +2990,20 @@ export function composeRuntime(options) {
         heldContents.set(key, made);
         return made;
     }
-    async function keptTogether({ local, parts }) {
-        const live = parts.filter((one) => one.live() && transfers.has(one.locator));
-        await local.keepParts(live.map(({ locator, token, part }) => ({ locator, token, part })));
-        for (const { locator, token, part } of live) {
-            const held = keptParts.get(locator) ?? new Map();
-            keptParts.set(locator, held.set(token, part.byteLength));
-            arrivals.get(locator)?.delete(token);
-        }
-        queueReadiness();
+    async function abandoned(local, locator) {
+        await local.abandon(locator);
+        setBack(locator);
+        untransferred(locator);
+        liveQueries.recover();
+        sweep();
     }
     function staging(local, liveness) {
         const derived = async (locator, key, composition) => {
             underived.delete(locator);
             for (;;) {
-                await screened();
                 if (!liveness())
                     return false;
-                const done = await installWrite(async () => liveness()
+                const done = await finishingWrite(async () => liveness()
                     ? timed(deriveBudget, () => local.rederive(key, composition, deriveBudget.bytes, DERIVE_LONGEST_MS, DERIVE_FLOOR))
                     : null);
                 if (done === null)
@@ -3167,28 +3017,23 @@ export function composeRuntime(options) {
             held: (locator) => transfers.get(locator) ?? null,
             async turn(locator, step) {
                 installing(locator);
-                for (;;) {
-                    await screened();
-                    const release = step === 'downloading' ? await heldPart() : () => { };
-                    if (onScreen || closed)
-                        return release;
-                    release();
-                }
+                return step === 'downloading' ? heldStream() : () => { };
             },
-            queued(bytes) {
-                queuedBytes += bytes;
+            unqueued,
+            queued(text) {
+                queuedText += text;
                 return once(() => {
-                    queuedBytes -= bytes;
+                    queuedText -= text;
                 });
             },
             arriving(locator) {
                 let ended = false;
                 return {
-                    at(token, bytes) {
-                        if (ended || keptParts.get(locator)?.has(token) === true)
+                    at(bytes) {
+                        if (ended)
                             return;
-                        const held = arrivals.get(locator) ?? new Map();
-                        arrivals.set(locator, held.set(token, bytes));
+                        arrivals.set(locator, bytes);
+                        streaming.add(locator);
                         const now = performance.now();
                         if (now - arrivalReported < ARRIVAL_REPORT_MS)
                             return;
@@ -3196,30 +3041,24 @@ export function composeRuntime(options) {
                         queueReadiness();
                     },
                     end() {
+                        if (ended)
+                            return;
                         ended = true;
-                        if (arrivals.delete(locator))
+                        if (streaming.delete(locator))
                             queueReadiness();
                     },
                 };
             },
-            received: (locator, token) => local.transferPart(locator, token),
-            keep: (locator, token, received) => gathered('kept parts', { local, parts: [{ locator, token, part: received, live: liveness }] }, (earlier, later) => earlier.local === later.local
-                ? { local: earlier.local, parts: [...earlier.parts, ...later.parts] }
-                : null, keptTogether),
-            announced(locator) {
-                const later = announced.get(locator);
-                return later === undefined ? [] : [later];
-            },
-            async stage(record, page, composition, written) {
+            streamed: options.adapter.roomStream !== undefined,
+            async stage(record, page, composition) {
                 const { locator } = record;
-                installing(locator, record.inventory);
-                await screened();
+                installing(locator);
                 if (!liveness())
                     return null;
                 const key = await installWrite(async () => {
                     if (!liveness())
                         return null;
-                    return local.stage(record, composition, page, written ?? undefined);
+                    return local.stage(record, composition, page);
                 });
                 if (key === null || !liveness())
                     return null;
@@ -3227,10 +3066,6 @@ export function composeRuntime(options) {
                 const prior = transfers.get(locator)?.done.bytes ?? 0;
                 const held = { ...record, key };
                 transfers.set(locator, held);
-                if (written !== null) {
-                    keptParts.get(locator)?.delete(written);
-                    arrivals.get(locator)?.delete(written);
-                }
                 if (arrived)
                     liveQueries.recover();
                 installing(locator);
@@ -3249,26 +3084,21 @@ export function composeRuntime(options) {
                 return refreshingOf(local, key, composition, liveness, locator);
             },
             abandon: (locator) => exclusive(async () => {
-                if (!liveness())
-                    return;
-                await local.abandon(locator);
-                untransferred(locator);
-                liveQueries.recover();
-                sweep();
+                if (liveness())
+                    await abandoned(local, locator);
             }),
-            setAside: (locator) => exclusive(async () => {
+            setAside: async (locator) => {
                 if (!liveness())
                     return;
-                await local.abandon(locator, true);
+                setBack(locator);
                 untransferred(locator);
                 liveQueries.recover();
-            }),
+            },
             release: (key) => exclusive(async () => {
                 await local.release(key);
                 sweep();
             }),
             content: (key) => heldContentOf(local, key),
-            validate: (record, view) => validatedRoom(local, record, view, null),
         };
     }
     function reusable(room, local) {
@@ -3280,7 +3110,6 @@ export function composeRuntime(options) {
     async function pullBootstrap(authorized, room, local, liveness) {
         if (!liveness())
             return unconfirmed;
-        const turn = generation;
         if (replicas.has(room.locator)) {
             catching.add(room.locator);
             liveQueries.recover();
@@ -3303,9 +3132,6 @@ export function composeRuntime(options) {
             journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
             throw error;
         }
-        finally {
-            reads.finished(room.locator, turn);
-        }
     }
     function caughtUpTo(locator) {
         if (catching.delete(locator))
@@ -3313,72 +3139,82 @@ export function composeRuntime(options) {
     }
     function behind(room) {
         const held = replicas.get(room.locator)?.record.roomVersion;
-        return (held !== undefined &&
-            [announced.get(room.locator), room.roomVersion].some((later) => later !== undefined && !options.adapter.reached(room.locator, held, later)));
+        return held !== undefined && !options.adapter.reached(room.locator, held, room.roomVersion);
     }
-    async function advance(room, local, authorized, live) {
-        const carried = reads.carried(room.locator);
-        const withheld = await advanceOnce(room, local, authorized, live);
-        if (withheld !== null || reads.carried(room.locator) === carried || !behind(room)) {
-            return withheld;
-        }
-        return advanceOnce(room, local, authorized, live);
+    function standingOf(locator) {
+        const held = replicas.get(locator);
+        return { key: held?.record.key ?? null, confirmed: held?.confirmed ?? 0 };
+    }
+    function stands(locator, from) {
+        const now = standingOf(locator);
+        return now.key === from.key && now.confirmed === from.confirmed;
     }
-    async function advanceOnce(room, local, authorized, running) {
+    async function advance(room, local, authorized, running) {
         const live = () => running() && !full;
         if (!live())
             return unconfirmed;
         const held = replicas.get(room.locator);
-        if (held !== undefined) {
-            const refreshed = await pullRefresh(authorized, held, live);
-            if (!live())
-                return unconfirmed;
-            if (refreshed.kind === 'still-current') {
-                stale.delete(room.locator);
-                if (sourceRefusals.has(room.locator))
-                    return null;
-                if (unreadable.delete(room.locator)) {
-                    scopedRefusals.delete(room.locator);
-                    list(room, true);
-                    emitRooms();
-                }
-                return null;
-            }
-            if (refreshed.kind === 'advanced') {
-                const landing = { kind: 'refreshed', base: refreshed.base };
-                if (!(await publish(local, room, refreshed.record, landing, live))) {
-                    const now = replicas.get(room.locator)?.record.roomVersion;
-                    const reached = now !== undefined &&
-                        options.adapter.reached(room.locator, now, refreshed.record.roomVersion);
-                    return reached ? null : advance(room, local, authorized, live);
-                }
-                await retainModel(local, room, modelOf(room.locator));
-                return null;
-            }
-            if (refreshed.kind !== 'beyond-horizon')
+        if (held !== undefined && options.adapter.roomStream !== undefined) {
+            stale.delete(room.locator);
+            name(room.locator);
+            return null;
+        }
+        const refresh = reads.refresh;
+        if (held !== undefined && refresh !== undefined) {
+            const refreshed = await ahead((hold) => refreshedRoom(room, local, authorized, held, live, hold, refresh));
+            if (refreshed === 'behind')
+                return advance(room, local, authorized, live);
+            if (refreshed !== 'beyond-horizon')
                 return refreshed;
-            if (opened !== null) {
-                owed.add(room.locator);
-                liveQueries.recover();
-                return unconfirmed;
-            }
-            if (reloadsDue.get(room.locator) === generation)
+            if (reloadsDue.has(room.locator))
                 return unconfirmed;
         }
+        const from = standingOf(room.locator);
         const bootstrapped = await pullBootstrap(authorized, room, local, live);
-        if (bootstrapped.kind === 'staged') {
-            await publish(local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed }, live);
+        if (bootstrapped.kind !== 'staged')
+            return live() ? bootstrapped : unconfirmed;
+        const landing = { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from };
+        if (await publish(local, room, bootstrapped.record, landing, live)) {
             return live() ? null : unconfirmed;
         }
-        return live() ? bootstrapped : unconfirmed;
+        return reachedBy(room.locator, bootstrapped.record.roomVersion)
+            ? null
+            : advance(room, local, authorized, live);
+    }
+    async function refreshedRoom(room, local, authorized, held, live, hold, refresh) {
+        const refreshed = await pullRefresh(authorized, held, live, hold, refresh);
+        if (!live())
+            return unconfirmed;
+        if (refreshed.kind === 'still-current') {
+            stale.delete(room.locator);
+            if (unreadable.delete(room.locator)) {
+                scopedRefusals.delete(room.locator);
+                list(room, true);
+                emitRooms();
+            }
+            return null;
+        }
+        if (refreshed.kind === 'advanced') {
+            const landing = {
+                kind: 'refreshed',
+                from: refreshed.from,
+                remodelled: refreshed.remodelled,
+            };
+            if (!(await publish(local, room, refreshed.record, landing, live))) {
+                const now = replicas.get(room.locator)?.record.roomVersion;
+                const reached = now !== undefined &&
+                    options.adapter.reached(room.locator, now, refreshed.record.roomVersion);
+                return reached ? null : 'behind';
+            }
+            await retainModel(local, room, modelOf(room.locator));
+            return null;
+        }
+        return refreshed.kind === 'beyond-horizon' ? 'beyond-horizon' : refreshed;
     }
     async function withhold(withheld, room, local, progress) {
         if (withheld.kind === 'unconfirmed')
             return;
-        if (withheld.kind === 'refused')
-            stale.delete(room.locator);
-        else
-            stale.add(room.locator);
+        stale.add(room.locator);
         if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
             const reset = withheld.kind === 'retryable-refusal' ? withheld.reset : undefined;
             repairable.set(room.locator, reset);
@@ -3400,30 +3236,10 @@ export function composeRuntime(options) {
             list(room, false);
             emitRooms();
         }
-        else if (withheld.kind === 'refused') {
-            refusedSource(room, withheld);
-        }
         else if (withheld.kind === 'revoked-authorization') {
             await refuse('revoked-authorization');
         }
     }
-    function refusedSource(room, { refusal }) {
-        sourceRefusals.set(room.locator, {
-            code: refusal.rule,
-            retryable: false,
-            fields: {
-                file: refusal.file,
-                ...(refusal.location === undefined ? {} : { location: refusal.location }),
-                ...(refusal.referrers === undefined ? {} : { referrers: refusal.referrers }),
-            },
-        });
-        declarationRefusals.delete(room.locator);
-        unreadable.add(room.locator);
-        list(room, false);
-        emitRooms();
-        moveTo({ ...status, ...attention() });
-        journal.record(`source refused ${room.locator} ${refusal.rule} ${refusal.file}`);
-    }
     function leaving(batch, result) {
         if (result.kind === 'expired')
             return { batch, returned: returnedBy('expired') };
@@ -3445,8 +3261,8 @@ export function composeRuntime(options) {
     function settling(acceptance) {
         return acceptance !== null && 'apply' in acceptance;
     }
-    function refusalOf(acceptance) {
-        return settling(acceptance) ? (acceptance.refused ?? null) : acceptance;
+    function failureOf(acceptance) {
+        return settling(acceptance) ? null : acceptance;
     }
     async function acceptance(room, local, submitted, accepted) {
         if (!continuing())
@@ -3469,34 +3285,6 @@ export function composeRuntime(options) {
                     ? accepted.roomVersion
                     : held,
             };
-            const overrides = new Map([
-                ...back.set.map((entry) => [entry.path, entry]),
-                ...back.removed.map((path) => [path, null]),
-            ]);
-            const refused = await validatedRoom(local, record, 'confirmed', { record: current.record, changed: [...overrides.keys()] }, overrides);
-            if (refused !== null) {
-                const key = pendingKey(room.locator, submitted.id);
-                return {
-                    locator: room.locator,
-                    left: [],
-                    commit: {
-                        rooms: [],
-                        writes: [
-                            {
-                                locator: room.locator,
-                                accepted: [{ id: submitted.id, roomVersion: accepted.roomVersion }],
-                            },
-                        ],
-                    },
-                    refused,
-                    apply() {
-                        const state = pendings.get(key);
-                        if (state !== undefined && !fences.has(room.locator))
-                            pendings.set(key, { ...state, accepted: accepted.roomVersion });
-                        return changeSet(room.locator, { queue: true });
-                    },
-                };
-            }
             changes = back;
         }
         const settled = await settlement(local, room.locator, current, record, current.queue.filter((batch) => batch.id !== submitted.id), { room: true, ...(changes === undefined ? {} : { changes }) });
@@ -3506,8 +3294,6 @@ export function composeRuntime(options) {
                 const set = settled.apply(answer);
                 pendings.delete(pendingKey(room.locator, submitted.id));
                 unreadable.delete(room.locator);
-                sourceRefusals.delete(room.locator);
-                declarationRefusals.delete(room.locator);
                 list(room, true);
                 return set;
             },
@@ -3525,13 +3311,9 @@ export function composeRuntime(options) {
         const failed = await exclusive(async () => {
             const adopting = await acceptance(room, local, submitted, accepted);
             await adoptedTogether(local, [adopting]);
-            return refusalOf(adopting);
+            return failureOf(adopting);
         });
-        if (failed === null)
-            return true;
-        if (failed.kind === 'refused' && continuing())
-            refusedSource(room, failed);
-        return false;
+        return failed === null;
     }
     async function adoptedMove(room, partner, local, submitted, accepted) {
         const other = discovered.get(partner);
@@ -3545,18 +3327,10 @@ export function composeRuntime(options) {
                     ...accepted.destination,
                 });
             await adoptedTogether(local, [left, arrived]);
-            const refusedArrival = refusalOf(arrived);
-            if (other !== undefined && refusedArrival?.kind === 'refused' && continuing()) {
-                refusedSource(other, refusedArrival);
-            }
-            return refusalOf(left);
+            return failureOf(left);
         });
         submitLater(partner);
-        if (failed === null)
-            return true;
-        if (failed.kind === 'refused' && continuing())
-            refusedSource(room, failed);
-        return false;
+        return failed === null;
     }
     function queueIn(locator) {
         return replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? [];
@@ -3679,8 +3453,6 @@ export function composeRuntime(options) {
             if (replica === undefined || head === undefined)
                 return 'done';
             const state = pendings.get(pendingKey(room.locator, head.id));
-            if (state?.accepted !== undefined)
-                return 'done';
             const partner = partnerOf(head, room.locator);
             if (partner !== null && !leavingIn(head, room.locator)) {
                 submitLater(partner);
@@ -3794,12 +3566,12 @@ export function composeRuntime(options) {
                 }
                 if (result.kind === 'expired') {
                     await exclusive(() => mark(local, room.locator, head, { state: 'waiting' }, partner !== null && lost));
-                    const there = other === undefined ? null : await advance(other, local, authorized, continuing);
+                    const there = other === undefined ? null : await advanced(other, local, authorized);
                     if (other !== undefined && there !== null) {
                         await withhold(there, other, local, progress);
                         return 'done';
                     }
-                    const withheld = await advance(room, local, authorized, continuing);
+                    const withheld = await advanced(room, local, authorized);
                     if (withheld !== null) {
                         await withhold(withheld, room, local, progress);
                         return 'done';
@@ -3821,8 +3593,8 @@ export function composeRuntime(options) {
             if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
                 const left = leaving(head, result);
                 const refreshed = async () => ({
-                    there: other === undefined ? null : await advance(other, local, authorized, continuing),
-                    here: await advance(room, local, authorized, continuing),
+                    there: other === undefined ? null : await advanced(other, local, authorized),
+                    here: await advanced(room, local, authorized),
                 });
                 const judged = result.kind === 'conflicted' && other !== undefined ? await refreshed() : null;
                 if (judged !== null && (judged.there !== null || judged.here !== null)) {
@@ -3926,25 +3698,22 @@ export function composeRuntime(options) {
             if (signal.aborted)
                 return;
             const progress = { complete: true, reachable: true };
-            await roomTask(room.locator, async (live) => {
-                await Promise.race([
-                    reload(room, local, progress, () => live() && !signal.aborted),
-                    abandonedOn(signal),
-                ]);
-            });
+            await roomTask(room.locator, (live) => reload(room, local, progress, live));
             if (signal.aborted)
                 return;
             await rest(progress);
         }
     }
     function awaitingAnswer(locator) {
+        answering.get(locator)?.release();
         let release = () => { };
-        const awaited = new Promise((resolve) => {
+        const answered = new Promise((resolve) => {
             release = resolve;
         });
-        answering.set(locator, { generation, answered: awaited });
+        const awaited = { answered, release };
+        answering.set(locator, awaited);
         return () => {
-            if (answering.get(locator)?.answered === awaited)
+            if (answering.get(locator) === awaited)
                 answering.delete(locator);
             release();
         };
@@ -3971,26 +3740,13 @@ export function composeRuntime(options) {
             const held = replicas.get(room.locator);
             let changed = null;
             if (held !== undefined) {
-                const declared = {
+                const record = {
                     ...held.record,
                     operations: room.operations,
                     replica: room.replica,
                     typedSelection: room.typedSelection ?? null,
                     model: next,
                 };
-                let read = 'staged';
-                if (!sameMembership(declared, held.record)) {
-                    const verdict = await validatedCollection(walkOf(local, held.record.key, 'confirmed'), lookupOf(local, held.record.key, 'confirmed'), composed(declared));
-                    read =
-                        verdict.verdict !== 'refuse'
-                            ? 'staged'
-                            : verdict.rule === 'model-unavailable'
-                                ? 'deferred'
-                                : { kind: 'refused', refusal: verdict };
-                }
-                const record = read === 'staged'
-                    ? declared
-                    : { ...declared, typedSelection: held.record.typedSelection };
                 const confirmedLayer = await sliceAt(record, 'confirmed', held.queue, held.overlaid);
                 const replayedLayer = await replayed(record, confirmedLayer, held.queue);
                 const diff = await overlayDiff(record, held, replayedLayer.visible, replayedLayer.touched);
@@ -4012,16 +3768,6 @@ export function composeRuntime(options) {
                     documents: answer.changed[room.locator] ?? [],
                     room: true,
                 });
-                if (read === 'staged' || read === 'deferred') {
-                    if (declarationRefusals.delete(room.locator)) {
-                        sourceRefusals.delete(room.locator);
-                        unreadable.delete(room.locator);
-                    }
-                }
-                else {
-                    refusedSource(room, read);
-                    declarationRefusals.add(room.locator);
-                }
             }
             heldModel(room, next);
             if (changed === null)
@@ -4066,6 +3812,17 @@ export function composeRuntime(options) {
         emitRooms();
         journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
     }
+    function name(locator) {
+        const stream = options.adapter.roomStream;
+        const record = replicas.get(locator)?.record;
+        const room = discovered.get(locator);
+        if (stream === undefined || record === undefined || room === undefined)
+            return;
+        if (!socketOpen || !handed || record.replica.selection !== room.replica.selection)
+            return;
+        naming += 1;
+        stream.hold([{ locator, roomVersion: record.roomVersion }]);
+    }
     function heldRooms(listed) {
         return listed.flatMap((room) => {
             const record = replicas.get(room.locator)?.record;
@@ -4083,14 +3840,20 @@ export function composeRuntime(options) {
             return outcome?.status === 'fulfilled' && outcome.value;
         });
         if (attempt === 'opened') {
+            naming += 1;
             options.adapter.roomStream?.hold(heldRooms(ready));
             handed = true;
         }
         discovering?.release();
-        const loaded = await Promise.allSettled(ready
-            .filter((room) => attempt === 'unstreamed' || !replicas.has(room.locator))
-            .map((room) => roomTask(room.locator, (held) => loadRoom(room, local, progress, held))));
-        const failed = [...prepared, ...loaded].find((room) => room.status === 'rejected');
+        for (const room of ready) {
+            if (attempt !== 'unstreamed' && replicas.has(room.locator)) {
+                if (attempt === 'authorized')
+                    name(room.locator);
+                continue;
+            }
+            void roomTask(room.locator, (live) => loadRoom(room, local, progress, live)).then(() => rest(progress));
+        }
+        const failed = prepared.find((room) => room.status === 'rejected');
         if (failed !== undefined)
             throw failed.reason;
     }
@@ -4114,7 +3877,9 @@ export function composeRuntime(options) {
         return room.replica.admission === 'admitted';
     }
     async function caughtUp(room, local, progress, live) {
-        if (authorization === undefined || !live() || !behind(room))
+        if (options.adapter.roomStream !== undefined || authorization === undefined)
+            return;
+        if (!live() || !behind(room))
             return;
         const withheld = await advance(room, local, authorization, live);
         if (withheld !== null)
@@ -4127,6 +3892,8 @@ export function composeRuntime(options) {
     async function loadRoom(room, local, progress, live) {
         if (!live() || authorization === undefined)
             return;
+        if (replicas.has(room.locator) && !(await prepareRoom(room, local, progress)))
+            return;
         if (replicas.has(room.locator) && revoked(room.locator)) {
             await reload(room, local, progress, live);
             return;
@@ -4144,13 +3911,14 @@ export function composeRuntime(options) {
                 reloadsDue.delete(room.locator);
             if (!live() || authorization === undefined)
                 return;
+            const from = standingOf(room.locator);
             const bootstrapped = await pullBootstrap(authorization, room, local, live);
             if (bootstrapped.kind !== 'staged') {
                 if (live())
                     await withhold(bootstrapped, room, local, progress);
                 return;
             }
-            await publish(local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed }, live);
+            await publish(local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
             await caughtUp(room, local, progress, live);
         }
         finally {
@@ -4259,23 +4027,45 @@ export function composeRuntime(options) {
         }
     }
     async function admittedRead(work) {
-        if (roomReads.generation !== generation) {
-            roomReads = { generation, free: ROOM_READS, waiting: [] };
+        while (roomReads.free === 0) {
+            await new Promise((admit) => roomReads.waiting.push(admit));
         }
-        const reads = roomReads;
-        while (reads.free === 0)
-            await new Promise((admit) => reads.waiting.push(admit));
-        reads.free -= 1;
+        roomReads.free -= 1;
         try {
             await work();
         }
         finally {
-            reads.free += 1;
-            reads.waiting.shift()?.();
+            roomReads.free += 1;
+            roomReads.waiting.shift()?.();
         }
     }
+    function inRoom(locator, work) {
+        roomWork += 1;
+        const ran = (roomLanes.get(locator) ?? Promise.resolve()).then(async () => {
+            try {
+                return await work(continuing);
+            }
+            finally {
+                roomWork -= 1;
+            }
+        });
+        const chain = ran.then(() => undefined, () => undefined);
+        roomLanes.set(locator, chain);
+        working.add(chain);
+        void chain.finally(() => {
+            working.delete(chain);
+            if (roomLanes.get(locator) === chain)
+                roomLanes.delete(locator);
+        });
+        return ran;
+    }
     function roomTask(locator, work) {
-        return task(roomLane(locator), (live) => admittedRead(() => work(live)));
+        if (stopping)
+            return Promise.resolve();
+        return inRoom(locator, (live) => admittedRead(() => work(live))).catch(() => undefined);
+    }
+    function advanced(room, local, authorized) {
+        return inRoom(room.locator, (live) => advance(room, local, authorized, live));
     }
     function task(lane, work) {
         if (stopping)
@@ -4299,15 +4089,12 @@ export function composeRuntime(options) {
             }
             const progress = { complete: true, reachable: true };
             const gate = discover();
-            if (attempt === 'opened')
-                opened = generation;
-            underway = attempt === 'opened' ? { generation, progress } : null;
+            underway = attempt === 'opened' ? progress : null;
             if (attempt === 'opened')
                 streamed = progress;
             complete = false;
             recorded = false;
             moveTo(transferring(status));
-            handed = false;
             try {
                 const local = await openLocal();
                 if (!live())
@@ -4335,7 +4122,6 @@ export function composeRuntime(options) {
             if (handed || closed || progress.reachable)
                 return;
             underway = null;
-            opened = null;
             journal.record('connection reopen');
             await rest(progress, live);
             options.adapter.roomStream?.reopen();
@@ -4375,11 +4161,11 @@ export function composeRuntime(options) {
         notifyDiscovered();
         const opened = socketOpen;
         socketOpen = false;
+        handed = false;
+        naming = 0;
         connectionLost();
-        if (lost) {
-            reads.lost();
+        if (lost)
             conversations.lost();
-        }
         if (revoked) {
             void refuse('revoked-authorization');
             return;
@@ -4394,14 +4180,13 @@ export function composeRuntime(options) {
         });
     }
     function applyOpening(expired) {
-        const progress = underway?.generation === generation ? underway.progress : null;
+        const progress = underway;
+        underway = null;
+        naming = Math.max(0, naming - 1);
         const cycle = progress ?? { complete: true, reachable: true };
-        if (opened === generation)
-            opened = null;
         const reloading = progress === null ? [] : owedReloads(expired);
         const replacing = reloadNow((room) => expired.includes(room.locator) || reloading.includes(room.locator), cycle);
         return task(OPENING_LANE, async (live) => {
-            underway = null;
             if (!live())
                 return;
             if (progress === null) {
@@ -4409,20 +4194,14 @@ export function composeRuntime(options) {
                 await rest(cycle, live);
                 return;
             }
-            await roomsCarried([...expired, ...reloading]);
-            if (!live())
-                return;
             try {
                 const local = await openLocal();
-                const reloaded = await replacing;
+                await replacing;
                 if (progress.reachable) {
                     await settleModels([...discovered.values()].filter((room) => replicas.has(room.locator) &&
                         !expired.includes(room.locator) &&
                         !reloading.includes(room.locator)), 'current', local);
                 }
-                const failed = reloaded.find((outcome) => outcome.status === 'rejected');
-                if (failed !== undefined)
-                    throw failed.reason;
             }
             catch {
                 progress.complete = false;
@@ -4434,11 +4213,8 @@ export function composeRuntime(options) {
     }
     function owedReloads(expired) {
         const reloading = [...discovered.values()]
-            .filter((room) => replicas.has(room.locator) &&
-            !expired.includes(room.locator) &&
-            (owed.has(room.locator) || revoked(room.locator)))
+            .filter((room) => replicas.has(room.locator) && !expired.includes(room.locator) && revoked(room.locator))
             .map((room) => room.locator);
-        owed.clear();
         for (const locator of reloading)
             catching.add(locator);
         liveQueries.recover();
@@ -4447,16 +4223,17 @@ export function composeRuntime(options) {
     async function reloadNow(replaced, progress) {
         const reloaded = [...discovered.values()].filter((room) => replicas.has(room.locator) && replaced(room));
         for (const room of reloaded)
-            reloadsDue.set(room.locator, generation);
+            reloadsDue.add(room.locator);
         try {
             const local = await openLocal();
-            return await Promise.allSettled(reloaded.map((room) => roomTask(room.locator, (live) => reload(room, local, progress, live))));
+            for (const room of reloaded) {
+                void roomTask(room.locator, (live) => reload(room, local, progress, live)).then(() => rest(progress));
+            }
         }
         catch {
             for (const room of reloaded)
                 reloadsDue.delete(room.locator);
             progress.reachable = false;
-            return [];
         }
     }
     async function settleModels(held, status, local) {
@@ -4467,7 +4244,7 @@ export function composeRuntime(options) {
         const settled = await exclusive(async () => {
             if (!continuing())
                 return [];
-            const unchanged = held.filter((room) => owed(room) && !declarationRefusals.has(room.locator) && declaredAsHeld(room));
+            const unchanged = held.filter((room) => owed(room) && declaredAsHeld(room));
             for (const room of unchanged) {
                 const next = { ...modelOf(room.locator), status };
                 const replica = replicas.get(room.locator);
@@ -4527,14 +4304,10 @@ export function composeRuntime(options) {
         try {
             const local = await openLocal();
             await roomTask(locator, async (live) => {
-                const current = () => live() && !signal.aborted;
-                if (!current() || authorization === undefined)
+                if (!live() || authorization === undefined)
                     return;
-                const withheld = await Promise.race([
-                    advance(room, local, authorization, current),
-                    abandonedOn(signal),
-                ]);
-                if (withheld !== null && current())
+                const withheld = await advance(room, local, authorization, live);
+                if (withheld !== null && live())
                     await withhold(withheld, room, local, progress);
             });
         }
@@ -4589,14 +4362,11 @@ export function composeRuntime(options) {
                 progress.complete = false;
                 return;
             }
-            reads.applied();
             submitAll();
             for (const locator of stale)
                 if (repairable.has(locator))
                     repairLater(locator, {});
             await conversations.reconcile();
-            if (status.providerUnreachable)
-                conversations.reconnected();
             const reading = { complete: true, reachable: true };
             await conversations.catchUp(reading);
             if (progress.reachable && reading.reachable)
@@ -4622,7 +4392,7 @@ export function composeRuntime(options) {
         if (!live())
             return;
         let lastCompleted = status.lastCompleted;
-        let synced = complete && stale.size === 0 && !pending();
+        let synced = complete && roomWork === 0 && naming === 0 && stale.size === 0 && !pending();
         if (synced && !recorded) {
             const completedAt = new Date().toISOString();
             try {
@@ -4637,74 +4407,79 @@ export function composeRuntime(options) {
             }
         }
         moveTo({
-            state: pending() ? 'pending' : synced && complete ? 'synced' : 'syncing',
+            state: pending()
+                ? 'pending'
+                : synced && complete && roomWork === 0 && naming === 0
+                    ? 'synced'
+                    : 'syncing',
             lastCompleted,
-            providerUnreachable: !progress.reachable,
+            providerUnreachable: progress === null ? status.providerUnreachable : !progress.reachable,
             ...attention(),
         });
     }
     function discover() {
+        discovering?.release();
         let release = () => { };
         const done = new Promise((resolve) => {
             release = resolve;
         });
-        discovering = { generation, done, release };
+        discovering = { done, release };
         return discovering;
     }
-    function applyRoom(locator, roomVersion) {
-        announced.set(locator, roomVersion);
-        return task(roomLane(locator), async (live) => {
-            if (discovering?.generation === generation)
-                await discovering.done;
-            const saving = answering.get(locator);
-            if (saving?.generation === generation)
-                await saving.answered;
-            if (!live() || authorization === undefined)
-                return;
-            const room = discovered.get(locator);
-            const held = replicas.get(locator);
-            if (room === undefined || room.replica.admission !== 'admitted')
-                return;
-            if (held !== undefined &&
-                (held.record.replica.selection !== room.replica.selection ||
-                    options.adapter.reached(locator, held.record.roomVersion, roomVersion))) {
-                return;
-            }
-            const during = underway?.generation === generation ? underway.progress : null;
-            const progress = during ?? { complete: true, reachable: true };
-            if (during === null)
-                moveTo(transferring(status));
+    function applyRoom(change) {
+        const { locator } = change;
+        if (stopping)
+            return Promise.resolve();
+        return inRoom(locator, async (live) => {
+            await discovering?.done;
+            await answering.get(locator)?.answered;
+            const progress = underway ?? { complete: true, reachable: true };
             try {
                 const local = await openLocal();
-                await admittedRead(async () => {
-                    if (!live() || authorization === undefined)
-                        return;
-                    const withheld = await advance(room, local, authorization, live);
-                    if (withheld !== null)
-                        await withhold(withheld, room, local, progress);
-                });
+                for (;;) {
+                    if (!live())
+                        return null;
+                    const room = discovered.get(locator);
+                    const held = replicas.get(locator);
+                    if (room === undefined ||
+                        held === undefined ||
+                        room.replica.admission !== 'admitted' ||
+                        held.record.replica.selection !== room.replica.selection) {
+                        return null;
+                    }
+                    const at = held.record.roomVersion;
+                    if (options.adapter.reached(locator, at, change.roomVersion))
+                        return progress;
+                    if (!options.adapter.reached(locator, at, change.from)) {
+                        name(locator);
+                        return progress;
+                    }
+                    if (underway === null)
+                        moveTo(transferring(status));
+                    const writing = () => live() && !full;
+                    const refreshed = await ahead((hold) => pullRefresh(authorization ?? {}, held, writing, hold, () => change.read()));
+                    if (refreshed.kind !== 'advanced')
+                        return progress;
+                    const landing = {
+                        kind: 'refreshed',
+                        from: refreshed.from,
+                        remodelled: refreshed.remodelled,
+                    };
+                    if (await publish(local, room, refreshed.record, landing, writing)) {
+                        stale.delete(locator);
+                        await retainModel(local, room, modelOf(locator));
+                        return progress;
+                    }
+                }
             }
             catch {
+                if (!stale.has(locator))
+                    name(locator);
                 stale.add(locator);
+                return progress;
             }
-            finally {
-                if (during === null)
-                    await rest(progress, live);
-            }
-        });
+        }).then((progress) => rest(progress), () => undefined);
     }
-    function roomsCarried(replacing) {
-        const replaced = new Set(replacing.map(roomLane));
-        return Promise.all([...lanes]
-            .filter(([lane, held]) => lane !== OPENING_LANE && !replaced.has(lane) && held.generation === generation)
-            .map(([, held]) => held.chain));
-    }
-    const receipts = {
-        heads: async () => (await openLocal()).receivedHeads(),
-        parts: async (key, count) => (await openLocal()).receivedParts(key, count),
-        keep: async (key, head, part) => (await openLocal()).keepReceived(key, head, part),
-        drop: async (keys) => (await openLocal()).dropReceived(keys),
-    };
     function observeStream() {
         const stream = options.adapter.roomStream;
         if (stream === undefined || withdrawStream !== undefined)
@@ -4714,9 +4489,10 @@ export function composeRuntime(options) {
                 return;
             if (event.kind === 'opened') {
                 socketOpen = true;
+                handed = false;
+                naming = 0;
                 connectionLive();
                 generation += 1;
-                reads.opened();
                 conversations.reopened();
                 recovery.resume();
                 void sync('opened');
@@ -4728,15 +4504,8 @@ export function composeRuntime(options) {
             else if (event.kind === 'authority-changed')
                 void rediscover(event.scope);
             else
-                void applyRoom(event.locator, event.roomVersion);
-        }, receipts, heldRevisions);
-    }
-    async function heldRevisions(locator, paths) {
-        const held = replicas.get(locator);
-        if (held === undefined || paths.length === 0)
-            return new Map();
-        const entries = await (await openLocal()).entries(held.record.key, 'confirmed', paths);
-        return new Map(entries.flatMap(({ path, revision }) => revision === null ? [] : [[path, revision]]));
+                void applyRoom(event);
+        });
     }
     function writesHeld() {
         return serviceMode === 'write-halted' || haltedRefusal;
@@ -4809,8 +4578,6 @@ export function composeRuntime(options) {
         notifyDiscovered();
         if (probing !== null)
             clearInterval(probing);
-        for (const resolve of shownWaiters.splice(0))
-            resolve();
         connectionLive();
         lockListeners.clear();
         readinessWatches.clear();
@@ -4835,6 +4602,7 @@ export function composeRuntime(options) {
     }
     async function stop() {
         stopping = true;
+        inFlight.abort();
         await recovery.retire();
         await Promise.all(working);
         await mutations;
@@ -5228,7 +4996,6 @@ export function composeRuntime(options) {
             journal.record(`persistence ${answer}`);
             queueReadiness();
         },
-        shown: screen,
         within: (reach, port) => {
             if (full)
                 void probed();