@agentshouse/mdruntime 0.1.0-c1ffd2bc60355 → 0.1.0-c219104d36ac5

package/dist/connection.js

@@ -1,5 +1,5 @@
 import { escapePointer, parseFrontmatter, roomTarget, target } from '@agentshouse/mdmodel';
-import { attachedModel, NO_ROOM_TYPES, roomTypesOf } from './attached-model.js';
+import { attachedModel, builtInModel, roomTypesOf } from './attached-model.js';
 import { cached, modelTypes, NO_MODEL, sameModel, } from './model.js';
 import { observing, whole } from './observation.js';
 import { filterOf, identityOf, planOf, plain, queryKey, } from './query.js';
@@ -12,18 +12,19 @@ import { bootstrapRoom } from './bootstrap.js';
 import { changeSet, mergeChangeSets } from './change-set.js';
 import { createConversationStore, } from './conversation.js';
 import { leaving as leavingIn, partnerOf, queuedFile, } from './change.js';
-import { available, collectionOf, unreadable as unreadableIn, validRoot, } from './collection.js';
+import { available, collectionOf, composedOf, unreadable as unreadableIn, validRoot, } from './collection.js';
 import { runtimeError } from './failure.js';
 import { createLog } from './log.js';
 import { binaryRecord } from './binary.js';
+import { attachedFile } from './file.js';
 import { openedFiles } from './opened.js';
-import { ABSENT_TARGET, absentBinary, binaryAnswer, binaryLinkAnswer, calledResult, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, undeclared, UNCERTAIN, UNREADABLE, } from './outcome.js';
+import { ABSENT_TARGET, absentBinary, attachAnswer, binaryAnswer, binaryLinkAnswer, calledResult, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, OFFLINE, undeclared, UNCERTAIN, UNREADABLE, } from './outcome.js';
 import { createRecovery } from './recovery.js';
 import { doorReads } from './reads.js';
 import { advancement } from './refresh.js';
 import { buildBatch, buildMove, joined, limiting, queuedDocuments, requeuing, } from './save.js';
 import { compositionOf, entryAt, landed, movedBy, overlayOf, replaying, returning, returnedPaths, sameMembership, slicing, slicingWith, standing, storedRecord, touchedBy, } from './replica.js';
-import { binaryBase, changedParts, changesOf, gatheredParts, held, heldFile, joinedDraft, moveTarget, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.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';
@@ -31,7 +32,7 @@ import { FencedMap } from './fence.js';
 import { sameBinary } from './overlay.js';
 import { paced, ROW_WEIGHT, stepped, yielded } from './turn.js';
 import { identityTime, roomDraftRevision } from './identity.js';
-import { beneath, normalize } from './paths.js';
+import { ancestors, beneath, normalize } from './paths.js';
 import { openRuntimeStore, } from './store.js';
 import { changedCleanly, sameComposition, validatedCollection, } from './validation.js';
 import { unconfirmed } from './transfer.js';
@@ -54,22 +55,23 @@ const CONVERSATION_LANE = 'conversations';
 const ROOM_READS = 256;
 const ROOM_ATTEMPTS = 16;
 const ERASE_BATCH = 512;
-const REDERIVE_BATCH = 256;
+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.
+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 STREAMS_HELD = 4;
+const NOTHING_HELD = { parts: 0, bytes: 0 };
+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 ARRIVAL_REPORT_MS = 250;
-const INSTALL_STEPS = [
-    'writing',
-    'downloading',
-    'replaying',
-    'listing',
-];
 const CLEAN_CHANGES = 2_000;
 // A Room that locks offline stays readable this long after the connection drops, so a laptop waking or changing network keeps working while a disconnected device locks soon after.
 const LOCK_GRACE_MS = 120_000;
@@ -93,7 +95,7 @@ function pendingKey(locator, id) {
 }
 export function composeRuntime(options) {
     const localSaves = options.adapter.localSaves === true;
-    const roomTypes = roomTypesOf(options.adapter.roomTypes);
+    const roomTypes = roomTypesOf(options.adapter.roomTypes, options.adapter.nameableRoomTypes);
     let authorization = options.authorization;
     let opening;
     const fences = new Map();
@@ -103,20 +105,23 @@ export function composeRuntime(options) {
     const fencedSince = (locator, since) => fences.has(locator) || (lastFenced.get(locator) ?? 0) > since;
     let discoveries = 0;
     const replicas = new FencedMap(isFenced);
+    const reopened = new Set();
+    const usableWhenHeld = options.usableWhenHeld ?? [];
     const queuesWithoutReplica = new FencedMap(isFenced);
     const pendings = new Map();
     const seeds = new Map();
     const seedWatchers = new Map();
     const roomDrafts = new FencedMap(isFenced);
+    const attachedFiles = new FencedMap(isFenced);
     const presentations = new Map();
     let limits = [];
     let capabilities = [];
     const rooms = new FencedMap(isFenced);
     const counted = new Map();
     const unreadable = new Set();
-    const isModelFenced = (key) => isFenced(key.slice(key.indexOf(' ') + 1));
-    const models = new FencedMap(isModelFenced);
-    const liveModels = new FencedMap(isModelFenced);
+    const builtIn = builtInModel(roomTypes);
+    const models = new FencedMap(isFenced);
+    const liveModels = new FencedMap(isFenced);
     const invalidModels = new Set();
     const discovered = new Map();
     const reads = doorReads(options.adapter, (locator) => discovered.get(locator), () => generation);
@@ -124,23 +129,19 @@ export function composeRuntime(options) {
     const scopedRefusals = new Map();
     const sourceRefusals = new Map();
     const declarationRefusals = new Set();
-    function modelKey(locator, attached) {
-        return `${attached} ${locator}`;
+    function modelOf(locator) {
+        return models.get(locator) ?? NO_MODEL;
     }
-    function modelOf(locator, attached = 'collection') {
-        return models.get(modelKey(locator, attached)) ?? NO_MODEL;
-    }
-    function savedModel(locator, attached) {
-        return invalidModels.has(modelKey(locator, attached))
+    function savedModel(locator) {
+        return invalidModels.has(locator)
             ? { status: 'unavailable', reason: 'revoked' }
-            : modelOf(locator, attached);
+            : modelOf(locator);
+    }
+    function composed(record) {
+        return compositionOf(record, builtIn);
     }
     function compositionFor(record) {
-        return compositionOf({
-            ...record,
-            model: savedModel(record.locator, 'collection'),
-            selectionModel: savedModel(record.locator, 'typed-selection'),
-        });
+        return composed({ ...record, model: savedModel(record.locator) });
     }
     let refusal = null;
     let storageLoss = null;
@@ -174,6 +175,7 @@ export function composeRuntime(options) {
     let mutations = Promise.resolve();
     let gathering = null;
     const roomListeners = new Set();
+    const unlistedRooms = new Set();
     const refusalListeners = new Set();
     const storageLossListeners = new Set();
     const statusListeners = new Set();
@@ -217,15 +219,31 @@ export function composeRuntime(options) {
     let readinessQueued = false;
     const catching = new Set();
     const transfers = new FencedMap(isFenced);
-    const installs = new Map();
+    const installs = new Set();
     const arrivals = new Map();
+    const streaming = new Set();
+    const underived = new Map();
+    const unindexed = new Map();
+    const unchecked = new Map();
     let arrivalReported = 0;
     let onScreen = options.shell.onScreen;
     const shownWaiters = [];
-    let partsFree = PARTS_HELD;
-    const partWaiters = [];
-    let stageBytes = STAGE_FLOOR * 4;
-    let installWrites = Promise.resolve();
+    let streams = { generation, free: STREAMS_HELD };
+    let queuedBytes = 0;
+    const installWaiters = [];
+    const stageBudget = {
+        bytes: STAGE_FLOOR * 4,
+        floor: STAGE_FLOOR,
+        ceiling: STAGE_BYTES,
+        aim: STAGE_AIM_MS,
+    };
+    const deriveBudget = {
+        bytes: DERIVE_FLOOR * 4,
+        floor: DERIVE_FLOOR,
+        ceiling: DERIVE_BYTES,
+        aim: DERIVE_AIM_MS,
+    };
+    const installTurns = { busy: false, ahead: 0, finishing: [], starting: [] };
     const conversations = createConversationStore({
         agents: declaredAgents,
         documents: (declaration, after) => rowsQuery(planOf({
@@ -246,6 +264,7 @@ export function composeRuntime(options) {
         stream: () => options.adapter.conversations,
         publish: publishChangeSet,
         online: () => connectionOf() !== 'unreachable' && refusal === null,
+        listed: () => roomsListed,
         full: () => full,
         closed: () => closed,
         unanswered: resendLater,
@@ -253,10 +272,19 @@ export function composeRuntime(options) {
     });
     const journal = createLog();
     const keptFiles = openedFiles(database, isFenced);
-    let notifyReady = () => { };
+    let readyFromStore = () => { };
     const ready = new Promise((resolve) => {
-        notifyReady = resolve;
+        readyFromStore = resolve;
+    });
+    let notifyDiscovered = () => { };
+    const firstDiscovery = new Promise((resolve) => {
+        notifyDiscovered = resolve;
     });
+    let roomsNamed = false;
+    function notifyReady() {
+        notifyDiscovered();
+        readyFromStore();
+    }
     function rememberRoomDraft(record) {
         const room = roomDrafts.get(record.locator) ?? new Map();
         room.set(record.path, record);
@@ -276,7 +304,7 @@ export function composeRuntime(options) {
             return undefined;
         const local = await openLocal();
         const slice = await stepped(slicing(await local.entries(held.record.key, 'visible', paths), paths));
-        return { ...slice, collection: collectionOf(slice.documents, compositionOf(held.record)) };
+        return { ...slice, collection: collectionOf(slice.documents, composed(held.record)) };
     }
     function roomDraftOf(record, visible) {
         return structuredClone({
@@ -343,7 +371,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,
@@ -378,6 +408,20 @@ export function composeRuntime(options) {
             (queuesWithoutReplica.size > 0 ||
                 [...replicas.values()].some((replica) => replica.queue.length > 0)));
     }
+    function unsent() {
+        const changed = new Map();
+        for (const room of [...replicas.keys(), ...queuesWithoutReplica.keys()]) {
+            for (const { batch, state } of entriesOf(room)) {
+                if (state === 'accepted' || state === 'local')
+                    continue;
+                for (const { path } of batch.changes)
+                    changed.set(`${room}\u0000${path}`, { room, path });
+            }
+        }
+        return [...changed]
+            .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+            .map(([, change]) => change);
+    }
     function attention() {
         const attentionRequired = [];
         for (const record of [...roomDrafts.values()].flatMap((room) => [...room.values()])) {
@@ -410,7 +454,7 @@ export function composeRuntime(options) {
             if (reset === null || submission.reset < reset)
                 reset = submission.reset;
         }
-        return { attentionRequired, reset };
+        return { attentionRequired, unsent: unsent(), reset };
     }
     function documentsIn(locator) {
         return replicas.get(locator)?.count ?? 0;
@@ -483,7 +527,7 @@ export function composeRuntime(options) {
             const governed = governs(reach, room);
             const attached = [
                 ...(governed.collection ? [modelOf(room.locator)] : []),
-                ...(governed.selection ? [modelOf(room.locator, 'typed-selection')] : []),
+                ...(governed.selection ? [builtIn] : []),
             ];
             return {
                 locator: room.locator,
@@ -499,11 +543,26 @@ export function composeRuntime(options) {
         const value = listed();
         for (const listener of roomListeners)
             listener(value);
+        emitKnownRooms();
+    }
+    function emitKnownRooms() {
+        conversations.learned();
+        if (unlistedRooms.size === 0)
+            return;
+        if (!roomsListed && rooms.size === 0 && refusal === null && !status.providerUnreachable)
+            return;
+        const value = listed();
+        for (const listener of [...unlistedRooms]) {
+            unlistedRooms.delete(listener);
+            roomListeners.add(listener);
+            listener(value);
+        }
     }
     function emitRefusal() {
         queueReadiness();
         for (const listener of refusalListeners)
             listener(refusal);
+        emitKnownRooms();
     }
     function emitStorageLoss() {
         queueReadiness();
@@ -524,6 +583,7 @@ export function composeRuntime(options) {
         if (closed)
             return;
         queueReadiness();
+        emitKnownRooms();
         const next = status.state === 'synced' && !conversations.current()
             ? { ...status, state: 'syncing' }
             : status;
@@ -567,11 +627,14 @@ export function composeRuntime(options) {
             if (held === undefined || closed || held.indexed)
                 return;
             const key = held.record.key;
-            const done = await exclusive(async () => (await openLocal()).rederive(key, REDERIVE_BATCH));
+            const done = await exclusive(async () => {
+                const local = await openLocal();
+                return timed(deriveBudget, () => local.rederive(key, composed(held.record), deriveBudget.bytes, DERIVE_LONGEST_MS, DERIVE_FLOOR));
+            });
             const now = replicas.get(locator);
             if (now?.record.key !== key)
                 continue;
-            if (!done)
+            if (!done.done)
                 continue;
             replicas.set(locator, { ...now, indexed: true });
             publishChangeSet(changeSet(locator, { documents: null }));
@@ -610,7 +673,11 @@ export function composeRuntime(options) {
         })();
     }
     function roomsOfReach(reach) {
-        return new Set([...reach.rooms, ...reach.documents.map(roomOfKey)]);
+        return new Set([
+            ...reach.rooms,
+            ...reach.documents.map(roomOfKey),
+            ...reach.areas.flatMap((area) => (area.types.length === 0 ? [] : [area.room])),
+        ]);
     }
     function reachedRooms(plan) {
         const reached = plan.reach === null ? null : roomsOfReach(plan.reach);
@@ -728,9 +795,9 @@ export function composeRuntime(options) {
         const rooms = { done: 0, total: 0 };
         const parts = { done: 0, total: 0 };
         const bytes = { done: 0, total: 0 };
-        const received = { done: 0, total: 0 };
-        const steps = new Set();
-        let waiting = false;
+        let installing = 0;
+        let downloading = false;
+        let checking = 0;
         for (const { room, state } of coverage) {
             if (state === 'unadmitted')
                 continue;
@@ -738,35 +805,43 @@ export function composeRuntime(options) {
             if (state === 'complete')
                 rooms.done += 1;
             const transfer = transfers.get(room);
-            const held = installs.get(room);
-            const inventory = transfer?.inventory ?? replicas.get(room)?.record.inventory ?? null;
-            if (inventory !== null) {
-                const done = transfer?.done ?? inventory;
-                const share = held?.share ?? null;
-                parts.total += inventory.parts;
-                bytes.total += inventory.bytes;
-                parts.done += done.parts;
-                bytes.done += done.bytes;
-                if (share !== null && share.entries > 0) {
-                    bytes.done += Math.floor((share.bytes * share.written) / share.entries);
-                }
-                received.total += inventory.bytes;
-                received.done += done.bytes + (share?.bytes ?? 0);
-                for (const arrived of arrivals.get(room)?.values() ?? [])
-                    received.done += arrived;
+            const underway = state === 'acquiring' || (installs.has(room) && state !== 'complete');
+            if (underway)
+                installing += 1;
+            if (underway && (streaming.has(room) || !arrivals.has(room)))
+                downloading = true;
+            if (transfer !== undefined) {
+                const check = unchecked.get(room);
+                const unchecking = check === undefined ? 0 : check.bytes * (1 - Math.min(1, check.done / check.text));
+                const owed = (unindexed.get(room) ?? []).reduce((sum, part) => sum + part.bytes, 0);
+                const arrived = arrivals.get(room);
+                parts.done += transfer.done.parts;
+                parts.total += Math.max(arrived?.parts ?? 0, transfer.done.parts);
+                bytes.done += transfer.done.bytes - Math.ceil(owed + unchecking);
+                checking += Math.ceil(owed + unchecking) - Math.ceil(owed);
+                bytes.total += Math.max(arrived?.bytes ?? 0, transfer.done.bytes);
+                continue;
             }
-            const installing = held !== undefined && state !== 'complete';
-            if (installing)
-                steps.add(held.step);
-            waiting ||= installing || state === 'acquiring';
-        }
+            const held = underway ? NOTHING_HELD : (replicas.get(room)?.record.inventory ?? NOTHING_HELD);
+            const arrived = arrivals.get(room) ?? held;
+            parts.done += held.parts;
+            parts.total += arrived.parts;
+            bytes.done += held.bytes;
+            bytes.total += arrived.bytes;
+        }
+        const step = installing === 0
+            ? null
+            : downloading
+                ? 'downloading'
+                : bytes.done + checking < bytes.total
+                    ? 'writing'
+                    : 'replaying';
         return {
-            step: INSTALL_STEPS.find((step) => steps.has(step)) ?? null,
-            paused: waiting && !onScreen ? 'hidden' : null,
+            step,
+            paused: installing > 0 && !onScreen ? 'hidden' : null,
             rooms,
             parts,
             bytes,
-            received,
         };
     }
     function readinessFor(port, reach) {
@@ -793,7 +868,8 @@ export function composeRuntime(options) {
             installation: installationOf(coverage),
             refused: refusedIn(required.rooms),
             lost: storageLoss !== null,
-            established: targets[port.target]?.established === true,
+            established: targets[port.target]?.established === true ||
+                (usableWhenHeld.includes(port.target) && required.rooms.some((room) => reopened.has(room))),
         });
     }
     function establish(name) {
@@ -846,7 +922,8 @@ export function composeRuntime(options) {
         probeEachMinute();
     }
     function installedTarget() {
-        return Object.values(targets).some((target) => target.established);
+        return ((usableWhenHeld.length > 0 && reopened.size > 0) ||
+            Object.values(targets).some((target) => target.established));
     }
     function probeEachMinute() {
         if (!full || probing !== null || closed || !installedTarget())
@@ -1004,6 +1081,10 @@ export function composeRuntime(options) {
     }
     function publishChangeSet(set) {
         applyChangeSet(set);
+        for (const { locator, path } of set.documents) {
+            if (path !== null)
+                attachedFiles.get(locator)?.delete(path);
+        }
         if (set.rooms.length > 0 ||
             [...new Set(set.documents.map(({ locator }) => locator))].some((locator) => rooms.has(locator) && counted.get(locator) !== documentsIn(locator)))
             emitRooms();
@@ -1029,7 +1110,7 @@ export function composeRuntime(options) {
                     const records = [...replicas].map(([locator, held]) => ({
                         locator,
                         held,
-                        record: { ...held.record, model: revoked, selectionModel: revoked },
+                        record: { ...held.record, model: revoked },
                     }));
                     let answer = null;
                     try {
@@ -1039,18 +1120,14 @@ export function composeRuntime(options) {
                                 locator,
                                 key: record.key,
                                 record: storedRecord(record),
-                                composition: compositionOf(record),
+                                composed: composedOf(composed(record)),
                             })),
                         });
                     }
                     catch {
                         journal.record('model revocation persistence failed');
                     }
-                    const keys = new Set(models.keys());
-                    for (const locator of rooms.keys()) {
-                        keys.add(modelKey(locator, 'collection'));
-                        keys.add(modelKey(locator, 'typed-selection'));
-                    }
+                    const keys = new Set([...models.keys(), ...rooms.keys()]);
                     for (const key of keys) {
                         invalidModels.add(key);
                         models.set(key, revoked);
@@ -1105,7 +1182,7 @@ export function composeRuntime(options) {
                 ? null
                 : {
                     roots: selection.roots,
-                    model: modelTypes(modelOf(room.locator, 'typed-selection')),
+                    model: modelTypes(builtIn),
                 },
             providerOwnedPaths: room.providerOwnedPaths,
             roomVersion: replicas.get(room.locator)?.record.roomVersion ?? null,
@@ -1194,7 +1271,8 @@ export function composeRuntime(options) {
             queuesWithoutReplica.delete(locator);
             rooms.delete(locator);
             roomDrafts.delete(locator);
-            transfers.delete(locator);
+            attachedFiles.delete(locator);
+            untransferred(locator);
             catching.delete(locator);
             discovered.delete(locator);
             announced.delete(locator);
@@ -1205,12 +1283,9 @@ export function composeRuntime(options) {
             scopedRefusals.delete(locator);
             sourceRefusals.delete(locator);
             declarationRefusals.delete(locator);
-            for (const attached of ['collection', 'typed-selection']) {
-                const key = modelKey(locator, attached);
-                models.delete(key);
-                liveModels.delete(key);
-                invalidModels.delete(key);
-            }
+            models.delete(locator);
+            liveModels.delete(locator);
+            invalidModels.delete(locator);
             journal.record(`room lost ${locator}`);
         }
         if (fresh.length === 0)
@@ -1258,7 +1333,14 @@ export function composeRuntime(options) {
         });
         await eraseFenced(fresh);
     }
-    function restored(key, persisted) {
+    function retyped(persisted) {
+        if (persisted.status === 'unavailable')
+            return persisted;
+        const { state } = attachedModel({ kind: 'model', snapshot: persisted.snapshot }, NO_MODEL, roomTypes);
+        return state.status === 'unavailable' ? state : { ...persisted, types: state.types };
+    }
+    function restored(key, held) {
+        const persisted = retyped(held);
         const prior = models.get(key);
         if (prior !== undefined &&
             prior.status !== 'unavailable' &&
@@ -1289,8 +1371,8 @@ export function composeRuntime(options) {
         const queuedBatches = new Map(queues.map((queue) => [queue.locator, queue.pending.map(({ batch }) => batch)]));
         targets = held.targets;
         transfers.clear();
-        for (const [locator, record] of held.transfers)
-            transfers.set(locator, record);
+        arrivals.clear();
+        streaming.clear();
         limits = held.providerLimits;
         capabilities = held.capabilities;
         member = held.member;
@@ -1300,7 +1382,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) {
@@ -1308,6 +1390,7 @@ export function composeRuntime(options) {
             }
         }
         replicas.clear();
+        reopened.clear();
         queuesWithoutReplica.clear();
         for (const [locator, queue] of queuedBatches) {
             if (!held.rooms.has(locator))
@@ -1316,9 +1399,8 @@ export function composeRuntime(options) {
         records.forEach((stored, index) => {
             if (fences.has(stored.locator))
                 return;
-            const model = restored(modelKey(stored.locator, 'collection'), stored.model);
-            const selectionModel = restored(modelKey(stored.locator, 'typed-selection'), stored.selectionModel);
-            const record = { ...stored, model, selectionModel };
+            const record = { ...stored, model: restored(stored.locator, stored.model) };
+            reopened.add(record.locator);
             replicas.set(record.locator, {
                 record,
                 queue: queuedBatches.get(record.locator) ?? [],
@@ -1329,25 +1411,28 @@ export function composeRuntime(options) {
             });
             const existing = rooms.get(record.locator);
             if (existing === undefined)
-                list(record, false);
+                list(record, record.roomVersion !== null);
             else {
                 rooms.set(record.locator, {
                     ...existing,
                     roomVersion: record.roomVersion,
                     operations: record.operations,
                     replica: record.replica,
-                    model: modelTypes(model),
+                    model: modelTypes(record.model),
                     typedSelection: record.typedSelection === null
                         ? null
-                        : {
-                            roots: record.typedSelection.roots,
-                            model: modelTypes(selectionModel),
-                        },
+                        : { roots: record.typedSelection.roots, model: modelTypes(builtIn) },
                 });
             }
         });
-        for (const key of held.orphans)
-            await opened.release(key);
+        try {
+            for (const key of held.orphans)
+                await opened.release(key);
+        }
+        catch (error) {
+            if (!refusedForSpace(error))
+                throw error;
+        }
         if (held.erasing || held.orphans.length > 0)
             queueMicrotask(sweep);
         return {
@@ -1529,7 +1614,7 @@ export function composeRuntime(options) {
         return { count: answer.counts[locator] ?? replicas.get(locator)?.count ?? 0, indexed };
     }
     function replayed(record, confirmedLayer, queue) {
-        return stepped(replaying(confirmedLayer, queue, record.locator, compositionOf(record)));
+        return stepped(replaying(confirmedLayer, queue, record.locator, composed(record)));
     }
     async function overlayDiff(record, before, visible, touched) {
         const kept = before !== undefined && before.record.key === record.key
@@ -1592,7 +1677,7 @@ export function composeRuntime(options) {
         const confirmedLayer = overrides === undefined
             ? read
             : await stepped(slicingWith(read, overrides.set, overrides.removed));
-        const composition = compositionOf(record);
+        const composition = composed(record);
         const { withdrawn, kept } = await stepped(standing(confirmedLayer, queue, withdrawable(locator), localSaves, locator, composition));
         const founded = kept.filter((batch) => !queue.includes(batch));
         const queueChanged = kept.length !== previousQueue.length || founded.length > 0;
@@ -1635,6 +1720,7 @@ export function composeRuntime(options) {
                     key: record.key,
                     record: storedRecord(record),
                     roots: record.typedSelection?.roots ?? [],
+                    composed: composedOf(composition),
                     ...settling.commit,
                     ...(overrides === undefined
                         ? {}
@@ -1698,35 +1784,25 @@ export function composeRuntime(options) {
         };
     }
     function adoptModels(locator, record) {
-        for (const [attached, model] of [
-            ['collection', record.model],
-            ['typed-selection', record.selectionModel],
-        ]) {
-            const key = modelKey(locator, attached);
-            models.set(key, model);
-            invalidModels.delete(key);
-            if (model.status === 'current')
-                liveModels.set(key, JSON.stringify(model.snapshot));
-            else if (model.status === 'unavailable')
-                liveModels.delete(key);
-        }
+        const model = record.model;
+        models.set(locator, model);
+        invalidModels.delete(locator);
+        if (model.status === 'current')
+            liveModels.set(locator, JSON.stringify(model.snapshot));
+        else if (model.status === 'unavailable')
+            liveModels.delete(locator);
     }
     function remodel(locator, answers, held) {
-        const taken = (answer, previous, attached) => {
-            if (answer === undefined)
-                return previous;
-            const { state, refused } = attachedModel(answer, previous, attached === 'collection' ? roomTypes : NO_ROOM_TYPES);
-            if (refused !== null) {
-                const where = refused.location === undefined ? '' : ` ${refused.location}`;
-                journal.record(`model invalid ${locator} ${attached} ${refused.identity} ${refused.rule}${where}`);
-            }
-            models.set(modelKey(locator, attached), state);
-            return state;
-        };
-        return {
-            collection: taken(answers?.collection, held.collection, 'collection'),
-            selection: taken(answers?.selection, held.selection, 'typed-selection'),
-        };
+        const answer = answers?.collection;
+        if (answer === undefined)
+            return held;
+        const { state, refused } = attachedModel(answer, held.collection, roomTypes);
+        if (refused !== null) {
+            const where = refused.location === undefined ? '' : ` ${refused.location}`;
+            journal.record(`model invalid ${locator} collection ${refused.identity} ${refused.rule}${where}`);
+        }
+        models.set(locator, state);
+        return { collection: state };
     }
     function publish(local, room, record, landing, live) {
         const landed = exclusive(async () => {
@@ -1753,14 +1829,13 @@ export function composeRuntime(options) {
                     ? {
                         room: true,
                         view: 'refreshed',
-                        commit: { refreshed: true, composition: compositionOf(record) },
+                        commit: { refreshed: true },
                     }
                     : {
                         room: true,
                         view: landing.refreshed ? 'refreshed' : 'confirmed',
                         commit: {
                             published: { from: prior?.record.key ?? null },
-                            composition: compositionOf(record),
                             ...(landing.refreshed ? { refreshed: true } : {}),
                         },
                     });
@@ -1772,7 +1847,7 @@ export function composeRuntime(options) {
                 return true;
             }
             if (landing.kind === 'bootstrapped') {
-                transfers.delete(room.locator);
+                untransferred(room.locator);
                 catching.delete(room.locator);
                 sweep();
             }
@@ -1819,12 +1894,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 = [];
@@ -1833,7 +1903,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 });
             }
@@ -1868,13 +1938,14 @@ export function composeRuntime(options) {
         const referring = removed.length === 0
             ? []
             : (await local.referrers(record.key, 'confirmed', removed, CHECKED_LINKS)).map(({ path }) => path);
-        const confirmedLayer = await sliceAt(record, 'confirmed', replica.queue, [...paths, ...referring], moved);
+        const confirmedLayer = await sliceAt(record, 'confirmed', replica.queue, [...paths, ...paths.flatMap(ancestors), ...referring], moved);
         const { visible } = await replayed(record, confirmedLayer, replica.queue);
-        const composition = compositionOf(record);
+        const composition = composed(record);
         return {
             record,
             confirmed: confirmedLayer,
             visible,
+            folders: new Set(await local.folders(record.key, 'visible', paths)),
             *visibleOver(queue) {
                 return (yield* replaying(confirmedLayer, queue, record.locator, composition)).visible;
             },
@@ -1886,13 +1957,7 @@ export function composeRuntime(options) {
             return false;
         const local = await openLocal();
         const roots = record.typedSelection?.roots ?? [];
-        if (composition.model.status === 'unavailable' &&
-            (await local.typedWithin(record.key, 'visible', roots, false))) {
-            return true;
-        }
-        return (composition.selection !== null &&
-            composition.selection.model.status === 'unavailable' &&
-            (await local.typedWithin(record.key, 'visible', roots, true)));
+        return local.typedWithin(record.key, 'visible', roots, false);
     }
     function textDiffers(left, right) {
         return ((left?.content ?? undefined) !== (right?.content ?? undefined) ||
@@ -1997,7 +2062,7 @@ export function composeRuntime(options) {
             const lookup = overriddenLookup(lookupOf(local, record.key, 'confirmed'), overrides);
             const clean = available(composition) &&
                 changed.length <= CLEAN_CHANGES &&
-                (await changedCleanly(changed, compositionOf(record), composition, {
+                (await changedCleanly(changed, composed(record), composition, {
                     lookup,
                     texts: textsOf(local, record.key, 'confirmed'),
                     referrers: referrersOf(local, record.key, 'confirmed'),
@@ -2028,6 +2093,7 @@ export function composeRuntime(options) {
             operations: room.operations,
             providerOwnedPaths: room.providerOwnedPaths,
             visible: saving.visible,
+            folders: saving.folders,
             queued: queuedDocuments(replica.queue),
             unmodeled: await unmodeledIn(record),
             validate: validatorOf(record, saving.confirmed),
@@ -2048,6 +2114,7 @@ export function composeRuntime(options) {
                 locator,
                 key: saving.record.key,
                 roots: saving.record.typedSelection?.roots ?? [],
+                composed: composedOf(composed(saving.record)),
                 overlay: diff.overlay,
             });
         }
@@ -2079,7 +2146,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);
@@ -2204,7 +2271,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));
@@ -2232,6 +2299,7 @@ export function composeRuntime(options) {
             providerLimits: limits,
             handle: room.handle,
             visible: saving.visible,
+            folders: saving.folders,
             changes,
             bases: parts.flatMap(({ bases }) => bases),
             queued: queuedDocuments(replica.queue),
@@ -2382,6 +2450,9 @@ export function composeRuntime(options) {
     async function readHistory(locator, path, query = {}) {
         if (closed || refusal !== null)
             return UNCERTAIN;
+        await firstDiscovery;
+        if (!roomsNamed)
+            return UNCERTAIN;
         try {
             await ensureAuthorization();
         }
@@ -2474,6 +2545,9 @@ export function composeRuntime(options) {
     async function transferBinary(request, transfer, answer) {
         if (closed || refusal !== null)
             return UNCERTAIN;
+        await firstDiscovery;
+        if (!roomsNamed)
+            return UNCERTAIN;
         try {
             await ensureAuthorization();
         }
@@ -2504,23 +2578,27 @@ export function composeRuntime(options) {
             return UNCERTAIN;
         }
     }
+    function fetchBinary(request, name) {
+        return transferBinary(request, (authorization) => keptFiles.fetch(name, () => options.adapter.binary(authorization, request)), binaryAnswer);
+    }
     async function readBinary(request, name) {
         if (closed)
             return UNCERTAIN;
         const held = await keptFiles.find(name);
         if (held !== null)
             return held;
-        return transferBinary(request, (authorization) => keptFiles.fetch(name, () => options.adapter.binary(authorization, request)), binaryAnswer);
+        return fetchBinary(request, name);
     }
     async function binaryPath(locator, path, revision) {
         if (revision !== undefined)
             return { kind: 'path', locator, path, revision };
         const replica = replicas.get(locator);
-        if (replica === undefined)
-            return null;
         const local = await openLocal();
-        const [held] = await local.entries(replica.record.key, 'visible', [path]);
-        if (held?.binary === undefined || held.binary === null)
+        const [held] = replica === undefined ? [] : await local.entries(replica.record.key, 'visible', [path]);
+        const attached = held === undefined ? attachedFiles.get(locator)?.get(path) : undefined;
+        if (attached !== undefined)
+            return { kind: 'path', locator, path, revision: attached.revision };
+        if (replica === undefined || held?.binary === undefined || held.binary === null)
             return null;
         if (held.binary.state === 'pending')
             return { kind: 'pending', localId: held.binary.localId };
@@ -2552,33 +2630,83 @@ export function composeRuntime(options) {
             revision: record.revision,
         };
     }
-    async function readBinaryPath(locator, path, revision) {
+    async function askedBinary(locator, path, revision) {
         await ready;
         const drafted = roomDrafts.get(locator)?.get(path)?.parts.file;
-        const asked = drafted !== undefined && drafted.localId === revision
+        return drafted !== undefined && drafted.localId === revision
             ? { kind: 'pending', localId: revision }
-            : await binaryPath(locator, path, revision);
+            : binaryPath(locator, path, revision);
+    }
+    function pendingBinary(locator, path, localId) {
+        const facts = queuedFacts(locator, path, localId);
+        return facts === null
+            ? absentBinary(path)
+            : {
+                kind: 'binary',
+                file: localId,
+                byteLength: facts.byteLength,
+                mediaType: facts.mediaType,
+            };
+    }
+    async function readBinaryPath(locator, path, revision) {
+        const asked = await askedBinary(locator, path, revision);
         if (asked === null)
             return absentBinary(path);
-        if (asked.kind === 'pending') {
-            const facts = queuedFacts(locator, path, asked.localId);
-            return facts === null
-                ? absentBinary(path)
-                : {
-                    kind: 'binary',
-                    file: asked.localId,
-                    byteLength: facts.byteLength,
-                    mediaType: facts.mediaType,
-                };
-        }
+        if (asked.kind === 'pending')
+            return pendingBinary(locator, path, asked.localId);
         return readBinary(asked, { locator, path: asked.path, revision: asked.revision });
     }
+    async function heldMediaType(locator, path) {
+        const replica = replicas.get(locator);
+        const [held] = replica === undefined
+            ? []
+            : await (await openLocal()).entries(replica.record.key, 'visible', [path]);
+        return held === undefined
+            ? attachedFiles.get(locator)?.get(path)?.mediaType
+            : held.binary?.mediaType;
+    }
+    function linkOf(asked, held) {
+        return transferBinary(asked, (authorization) => options.adapter.link(authorization, asked), (result) => binaryLinkAnswer(result, held));
+    }
     async function linkBinaryPath(locator, path, revision) {
         await ready;
         const asked = await binaryPath(locator, path, revision);
         if (asked === null || asked.kind === 'pending')
             return absentBinary(path);
-        return transferBinary(asked, (held) => options.adapter.link(held, asked), binaryLinkAnswer);
+        return linkOf(asked, revision === undefined ? await heldMediaType(locator, path) : undefined);
+    }
+    async function showBinaryPath(locator, path, revision) {
+        const asked = await askedBinary(locator, path, revision);
+        if (asked === null)
+            return absentBinary(path);
+        if (asked.kind === 'pending')
+            return pendingBinary(locator, path, asked.localId);
+        if (closed)
+            return UNCERTAIN;
+        const name = { locator, path: asked.path, revision: asked.revision };
+        const kept = await keptFiles.find(name);
+        if (kept !== null)
+            return kept;
+        const mediaType = await heldMediaType(locator, path);
+        if (mediaType?.startsWith('image/') === true)
+            return fetchBinary(asked, name);
+        return linkOf(asked, revision === undefined ? mediaType : undefined);
+    }
+    async function attachBinary(locator, file) {
+        await ready;
+        await firstDiscovery;
+        if (closed || !roomsNamed || connectionOf() === 'unreachable' || refusal !== null)
+            return OFFLINE;
+        const request = await attachedFile(locator, file);
+        return transferBinary({ locator, path: file.name }, async (held) => {
+            const result = await options.adapter.attach(held, request);
+            if (result.kind === 'attached') {
+                const landed = attachedFiles.get(locator) ?? new Map();
+                landed.set(result.path, { revision: result.revision, mediaType: request.mediaType });
+                attachedFiles.set(locator, landed);
+            }
+            return result;
+        }, attachAnswer);
     }
     function readPart(file, part) {
         return database.ask({ kind: 'file.part', key: file, part });
@@ -2753,18 +2881,25 @@ export function composeRuntime(options) {
             after = page.next;
         }
     }
-    async function validatedRoom(local, record, view, previous, overrides = null) {
-        const composition = compositionOf(record);
-        const modeled = record.model.status !== 'unavailable' || record.selectionModel.status !== 'unavailable';
+    async function validatedRoom(local, record, view, previous, overrides = null, checked = 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
+        const walking = overrides === null
             ? walkOf(local, record.key, view)
             : overriddenWalk(walkOf(local, record.key, view), overrides);
+        const walk = checked === null
+            ? walking
+            : async (after) => {
+                const page = await walking(after);
+                checked(page.entries.reduce((sum, entry) => sum + (entry.content?.length ?? 0), 0));
+                return page;
+            };
         let changes = null;
         let reshaped = false;
         if (previous !== null && previous.changed.length <= CLEAN_CHANGES) {
@@ -2789,11 +2924,11 @@ export function composeRuntime(options) {
         }
         const named = changes === null ? null : changes.map(({ path }) => path);
         const textChanged = changes === null || changes.length > 0 || reshaped;
-        const modelsChanged = previous === null || !sameComposition(compositionOf(previous.record), composition);
+        const modelsChanged = previous === null || !sameComposition(composed(previous.record), composition);
         if (modeled && (textChanged || modelsChanged)) {
             const clean = previous !== null &&
                 changes !== null &&
-                (await changedCleanly(changes, compositionOf(previous.record), composition, {
+                (await changedCleanly(changes, composed(previous.record), composition, {
                     lookup,
                     texts,
                     referrers: referrersOf(local, record.key, 'confirmed'),
@@ -2811,13 +2946,13 @@ export function composeRuntime(options) {
             return unreadableRoom(texts, walk, named);
         return null;
     }
-    function refreshingOf(local, key, liveness, replaying = null) {
-        const write = replaying === null ? exclusive : installWrite;
+    function refreshingOf(local, key, composition, liveness, replaying = null) {
+        const write = replaying === null ? exclusive : finishingWrite;
         return {
             async turn() {
                 if (replaying === null)
                     return;
-                installing(replaying, 'replaying');
+                installing(replaying);
                 await screened();
             },
             prior: async (paths) => new Map((await local.entries(key, 'refreshed', paths)).map((entry) => [entry.path, entry])),
@@ -2831,7 +2966,7 @@ export function composeRuntime(options) {
                     const staged = await write(async () => {
                         if (!liveness())
                             return false;
-                        await timed(() => local.refresh(key, last
+                        await timed(stageBudget, () => local.refresh(key, composition, last
                             ? { ...page, entries }
                             : { entries, removals: [], folders: [], folderRemovals: [] }));
                         return true;
@@ -2850,28 +2985,79 @@ export function composeRuntime(options) {
         let spent = 0;
         while (end < entries.length) {
             const size = (entries[end].content?.length ?? 0) + ROW_WEIGHT;
-            if (spent + size > stageBytes && end > from)
+            if (spent + size > stageBudget.bytes && end > from)
                 break;
             spent += size;
             end += 1;
         }
         return end;
     }
-    async function timed(work) {
+    async function timed(budget, work) {
         const started = performance.now();
         const done = await work();
         const spent = performance.now() - started;
-        if (spent < STAGE_AIM_MS / 2)
-            stageBytes = Math.min(STAGE_BYTES, Math.round(stageBytes * 1.5));
-        else if (spent > STAGE_AIM_MS * 2) {
-            stageBytes = Math.max(STAGE_FLOOR, Math.round(stageBytes / 1.5));
+        if (spent < budget.aim / 2)
+            budget.bytes = Math.min(budget.ceiling, Math.round(budget.bytes * 1.5));
+        else if (spent > budget.aim * 2) {
+            budget.bytes = Math.max(budget.floor, Math.round(budget.bytes / 1.5));
         }
         return done;
     }
     function installWrite(work) {
-        const next = installWrites.then(() => exclusive(work), () => exclusive(work));
-        installWrites = next.then(() => undefined, () => undefined);
-        return next;
+        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();
+        });
+    }
+    function nextInstallTurn() {
+        if (installTurns.busy || installTurns.ahead > 0)
+            return;
+        const turn = installTurns.finishing.shift() ?? installTurns.starting.shift();
+        if (turn === undefined)
+            return;
+        installTurns.busy = true;
+        turn();
+    }
+    async function ahead(work) {
+        let taken = false;
+        const hold = {
+            take() {
+                if (taken)
+                    return;
+                taken = true;
+                installTurns.ahead += 1;
+            },
+            release() {
+                if (!taken)
+                    return;
+                taken = false;
+                installTurns.ahead -= 1;
+                resumeInstall();
+            },
+        };
+        hold.take();
+        try {
+            return await work(hold);
+        }
+        finally {
+            hold.release();
+        }
+    }
+    function resumeInstall() {
+        if (installTurns.ahead > 0)
+            return;
+        void yielded().then(nextInstallTurn);
     }
     function screened() {
         if (onScreen || closed)
@@ -2879,24 +3065,73 @@ export function composeRuntime(options) {
         queueReadiness();
         return new Promise((resolve) => shownWaiters.push(resolve));
     }
-    async function heldPart() {
-        while (partsFree === 0)
-            await new Promise((admit) => partWaiters.push(admit));
-        partsFree -= 1;
-        return freed();
+    async function heldStream() {
+        for (;;) {
+            if (streams.generation !== generation)
+                streams = { generation, free: STREAMS_HELD };
+            const held = streams;
+            if (held.free > 0) {
+                held.free -= 1;
+                return once(() => {
+                    held.free += 1;
+                });
+            }
+            await new Promise((admit) => installWaiters.push(admit));
+        }
     }
-    function freed() {
+    async function unqueued() {
+        while (queuedBytes >= QUEUED_BYTES) {
+            await new Promise((admit) => installWaiters.push(admit));
+        }
+    }
+    function once(release) {
         let released = false;
         return () => {
             if (released)
                 return;
             released = true;
-            partsFree += 1;
-            partWaiters.shift()?.();
+            release();
+            for (const admit of installWaiters.splice(0))
+                admit();
         };
     }
-    function installing(locator, step, share = null) {
-        installs.set(locator, { step, share });
+    function installing(locator) {
+        installs.add(locator);
+        queueReadiness();
+    }
+    function untransferred(locator) {
+        transfers.delete(locator);
+        arrivals.delete(locator);
+        streaming.delete(locator);
+        underived.delete(locator);
+        unindexed.delete(locator);
+        unchecked.delete(locator);
+    }
+    function owedIndexes(locator, bytes, text) {
+        if (bytes <= 0 || text <= 0)
+            return;
+        unindexed.set(locator, [...(unindexed.get(locator) ?? []), { bytes: bytes / 2, text }]);
+        const check = unchecked.get(locator) ?? { bytes: 0, text: 0, done: 0 };
+        unchecked.set(locator, { ...check, bytes: check.bytes + bytes / 2, text: check.text + text });
+    }
+    function built(locator, { done, text }) {
+        const owed = unindexed.get(locator) ?? [];
+        let left = text;
+        while (!done && left > 0 && owed.length > 0) {
+            const [first] = owed;
+            if (left >= first.text) {
+                left -= first.text;
+                owed.shift();
+                continue;
+            }
+            owed[0] = {
+                bytes: (first.bytes * (first.text - left)) / first.text,
+                text: first.text - left,
+            };
+            left = 0;
+        }
+        if (done || owed.length === 0)
+            unindexed.delete(locator);
         queueReadiness();
     }
     function installed(locator) {
@@ -2914,7 +3149,7 @@ export function composeRuntime(options) {
         for (const resolve of shownWaiters.splice(0))
             resolve();
     }
-    async function pullRefresh(authorized, held, liveness) {
+    async function pullRefresh(authorized, held, liveness, hold) {
         if (!liveness())
             return unconfirmed;
         const turn = generation;
@@ -2923,7 +3158,18 @@ export function composeRuntime(options) {
         const local = await openLocal();
         try {
             await exclusive(() => local.unrefresh(record.key));
-            const result = await advancement(reads, authorized, record, (models, kept) => (liveness() ? remodel(record.locator, models, kept) : kept), liveness, refreshingOf(local, record.key, liveness));
+            const result = await advancement({
+                ...reads,
+                async refresh(authorization, request) {
+                    hold.release();
+                    try {
+                        return await reads.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;
@@ -2966,129 +3212,142 @@ export function composeRuntime(options) {
         return made;
     }
     function staging(local, liveness) {
+        const derived = async (locator, key, composition) => {
+            underived.delete(locator);
+            for (;;) {
+                await screened();
+                if (!liveness())
+                    return false;
+                const done = await finishingWrite(async () => liveness()
+                    ? timed(deriveBudget, () => local.rederive(key, composition, deriveBudget.bytes, DERIVE_LONGEST_MS, DERIVE_FLOOR))
+                    : null);
+                if (done === null)
+                    return false;
+                built(locator, done);
+                if (done.done)
+                    return true;
+            }
+        };
         return {
             held: (locator) => transfers.get(locator) ?? null,
             async turn(locator, step) {
-                installing(locator, step);
+                installing(locator);
                 for (;;) {
                     await screened();
-                    const release = step === 'downloading' ? await heldPart() : () => { };
+                    const release = step === 'downloading' ? await heldStream() : () => { };
                     if (onScreen || closed)
                         return release;
                     release();
                 }
             },
-            spare() {
-                if (!onScreen || closed || partsFree === 0)
-                    return null;
-                partsFree -= 1;
-                return freed();
+            unqueued,
+            queued(bytes) {
+                queuedBytes += bytes;
+                return once(() => {
+                    queuedBytes -= bytes;
+                });
             },
             arriving(locator) {
                 let ended = false;
                 return {
-                    at(token, bytes) {
+                    at(bytes) {
                         if (ended)
                             return;
-                        const held = arrivals.get(locator) ?? new Map();
-                        arrivals.set(locator, held.set(token, bytes));
+                        arrivals.set(locator, { parts: arrivals.get(locator)?.parts ?? 0, bytes });
+                        streaming.add(locator);
                         const now = performance.now();
                         if (now - arrivalReported < ARRIVAL_REPORT_MS)
                             return;
                         arrivalReported = now;
                         queueReadiness();
                     },
+                    part() {
+                        const arrived = arrivals.get(locator);
+                        arrivals.set(locator, {
+                            parts: (arrived?.parts ?? 0) + 1,
+                            bytes: arrived?.bytes ?? 0,
+                        });
+                        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) => installWrite(async () => {
-                if (liveness())
-                    await local.keepPart(locator, token, received);
-            }),
             announced(locator) {
                 const later = announced.get(locator);
                 return later === undefined ? [] : [later];
             },
-            async stage(record, page, composition, received) {
+            async stage(record, page, composition) {
                 const { locator } = record;
-                const whole = received?.byteLength ?? 0;
-                const from = record.writing?.written ?? 0;
-                const token = record.writing?.token ?? null;
-                const entries = page.entries.length;
-                let held = record;
-                if (token !== null)
-                    arrivals.get(locator)?.delete(token);
-                installing(locator, 'writing', { written: from, entries, bytes: whole });
-                for (let written = from;;) {
-                    await screened();
+                installing(locator);
+                await screened();
+                if (!liveness())
+                    return null;
+                const key = await installWrite(async () => {
                     if (!liveness())
                         return null;
-                    const end = batchEnd(page.entries, written);
-                    const last = end === entries;
-                    const next = last
-                        ? {
-                            ...held,
-                            writing: null,
-                            done: {
-                                parts: held.done.parts + (received === null ? 0 : 1),
-                                bytes: held.done.bytes + whole,
-                            },
-                        }
-                        : { ...held, writing: { token, written: end } };
-                    const key = await installWrite(async () => {
-                        if (!liveness())
-                            return null;
-                        return timed(() => local.stage(next, composition, {
-                            entries: page.entries.slice(written, end),
-                            folders: last ? page.folders : [],
-                        }, last && received !== null && token !== null ? token : undefined));
-                    });
-                    if (key === null)
-                        return null;
-                    const arrived = !transfers.has(locator);
-                    held = { ...next, key };
-                    transfers.set(locator, held);
-                    if (arrived)
-                        liveQueries.recover();
-                    if (last) {
-                        installing(locator, held.pageToken === null ? 'replaying' : 'downloading');
-                        liveQueries.recover();
-                        return held;
-                    }
-                    installing(locator, 'writing', { written: end, entries, bytes: whole });
-                    written = end;
-                }
+                    return local.stage(record, composition, page);
+                });
+                if (key === null || !liveness())
+                    return null;
+                const arrived = !transfers.has(locator);
+                const prior = transfers.get(locator)?.done.bytes ?? 0;
+                const held = { ...record, key };
+                transfers.set(locator, held);
+                if (arrived)
+                    liveQueries.recover();
+                installing(locator);
+                liveQueries.recover();
+                const text = page.entries.reduce((sum, entry) => sum + (entry.content?.length ?? 0), 0);
+                owedIndexes(locator, record.done.bytes - prior, text);
+                const owed = text + (underived.get(locator) ?? 0);
+                underived.set(locator, owed);
+                if (owed < deriveBudget.bytes)
+                    return held;
+                return (await derived(locator, key, composition)) ? held : null;
             },
-            async refreshing(locator, key) {
+            derive: derived,
+            async refreshing(locator, key, composition) {
                 await exclusive(() => local.unrefresh(key));
-                return refreshingOf(local, key, liveness, locator);
+                return refreshingOf(local, key, composition, liveness, locator);
             },
             abandon: (locator) => exclusive(async () => {
                 if (!liveness())
                     return;
                 await local.abandon(locator);
-                transfers.delete(locator);
+                untransferred(locator);
                 liveQueries.recover();
                 sweep();
             }),
-            setAside: (locator) => exclusive(async () => {
+            setAside: async (locator) => {
                 if (!liveness())
                     return;
-                await local.abandon(locator, true);
-                transfers.delete(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),
+            async validate(record, view) {
+                const { locator } = record;
+                const refused = await validatedRoom(local, record, view, null, null, (text) => {
+                    const check = unchecked.get(locator);
+                    if (check === undefined)
+                        return;
+                    unchecked.set(locator, { ...check, done: check.done + text });
+                    queueReadiness();
+                });
+                unchecked.delete(locator);
+                queueReadiness();
+                return refused;
+            },
         };
     }
     function reusable(room, local) {
@@ -3106,10 +3365,7 @@ export function composeRuntime(options) {
             liveQueries.recover();
         }
         try {
-            const result = await bootstrapRoom(reads, authorized, room, {
-                collection: modelOf(room.locator),
-                selection: modelOf(room.locator, 'typed-selection'),
-            }, (models, held) => (liveness() ? remodel(room.locator, models, held) : held), liveness, staging(local, liveness), reusable(room, local));
+            const result = await bootstrapRoom(reads, authorized, room, { collection: modelOf(room.locator) }, builtIn, (models, held) => (liveness() ? remodel(room.locator, models, held) : held), liveness, staging(local, liveness), reusable(room, local));
             const detail = result.kind === 'staged' ? result.record.roomVersion : result.kind;
             journal.record(`transfer bootstrap ${room.locator} ${detail}`);
             if (result.kind !== 'staged') {
@@ -3153,32 +3409,10 @@ export function composeRuntime(options) {
             return unconfirmed;
         const held = replicas.get(room.locator);
         if (held !== undefined) {
-            const refreshed = await pullRefresh(authorized, held, live);
-            if (!live())
-                return unconfirmed;
-            if (refreshed.kind === 'still-current') {
-                stale.delete(room.locator);
-                if (sourceRefusals.has(room.locator))
-                    return null;
-                if (unreadable.delete(room.locator)) {
-                    scopedRefusals.delete(room.locator);
-                    list(room, true);
-                    emitRooms();
-                }
-                return null;
-            }
-            if (refreshed.kind === 'advanced') {
-                const landing = { kind: 'refreshed', base: refreshed.base };
-                if (!(await publish(local, room, refreshed.record, landing, live))) {
-                    const now = replicas.get(room.locator)?.record.roomVersion;
-                    const reached = now !== undefined &&
-                        options.adapter.reached(room.locator, now, refreshed.record.roomVersion);
-                    return reached ? null : advance(room, local, authorized, live);
-                }
-                await retainModel(local, room, 'collection', modelOf(room.locator));
-                return null;
-            }
-            if (refreshed.kind !== 'beyond-horizon')
+            const refreshed = await ahead((hold) => refreshedRoom(room, local, authorized, held, live, hold));
+            if (refreshed === 'behind')
+                return advance(room, local, authorized, live);
+            if (refreshed !== 'beyond-horizon')
                 return refreshed;
             if (opened !== null) {
                 owed.add(room.locator);
@@ -3195,6 +3429,34 @@ export function composeRuntime(options) {
         }
         return live() ? bootstrapped : unconfirmed;
     }
+    async function refreshedRoom(room, local, authorized, held, live, hold) {
+        const refreshed = await pullRefresh(authorized, held, live, hold);
+        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 : '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;
@@ -3716,6 +3978,7 @@ export function composeRuntime(options) {
                             locator: room.locator,
                             key: before.record.key,
                             roots: before.record.typedSelection?.roots ?? [],
+                            composed: composedOf(composed(before.record)),
                             overlay: { set: [], cleared: [...before.overlaid] },
                         },
                     ]),
@@ -3771,16 +4034,17 @@ export function composeRuntime(options) {
             release();
         };
     }
-    async function retainModel(local, room, attached, next) {
-        const key = modelKey(room.locator, attached);
-        const previous = modelOf(room.locator, attached);
-        const heldBefore = replicas.get(room.locator)?.record;
-        if (JSON.stringify(previous) === JSON.stringify(next) &&
-            (heldBefore === undefined ||
-                (JSON.stringify(heldBefore.operations) === JSON.stringify(room.operations) &&
-                    JSON.stringify(heldBefore.replica) === JSON.stringify(room.replica) &&
-                    JSON.stringify(heldBefore.typedSelection) ===
-                        JSON.stringify(room.typedSelection ?? null))))
+    function declaredAsHeld(room) {
+        const held = replicas.get(room.locator)?.record;
+        return (held === undefined ||
+            (JSON.stringify(held.operations) === JSON.stringify(room.operations) &&
+                JSON.stringify(held.replica) === JSON.stringify(room.replica) &&
+                JSON.stringify(held.typedSelection) === JSON.stringify(room.typedSelection ?? null)));
+    }
+    async function retainModel(local, room, next) {
+        const key = room.locator;
+        const previous = modelOf(room.locator);
+        if (JSON.stringify(previous) === JSON.stringify(next) && declaredAsHeld(room))
             return;
         if (next.status === 'unavailable') {
             invalidModels.add(key);
@@ -3797,11 +4061,11 @@ export function composeRuntime(options) {
                     operations: room.operations,
                     replica: room.replica,
                     typedSelection: room.typedSelection ?? null,
-                    ...(attached === 'collection' ? { model: next } : { selectionModel: next }),
+                    model: next,
                 };
                 let read = 'staged';
                 if (!sameMembership(declared, held.record)) {
-                    const verdict = await validatedCollection(walkOf(local, held.record.key, 'confirmed'), lookupOf(local, held.record.key, 'confirmed'), compositionOf(declared));
+                    const verdict = await validatedCollection(walkOf(local, held.record.key, 'confirmed'), lookupOf(local, held.record.key, 'confirmed'), composed(declared));
                     read =
                         verdict.verdict !== 'refuse'
                             ? 'staged'
@@ -3822,7 +4086,7 @@ export function composeRuntime(options) {
                             key: record.key,
                             record: storedRecord(record),
                             roots: record.typedSelection?.roots ?? [],
-                            composition: compositionOf(record),
+                            composed: composedOf(composed(record)),
                             overlay: diff.overlay,
                         },
                     ],
@@ -3844,18 +4108,21 @@ export function composeRuntime(options) {
                     declarationRefusals.add(room.locator);
                 }
             }
-            models.set(key, next);
-            if (next.status === 'current') {
-                liveModels.set(key, JSON.stringify(next.snapshot));
-                invalidModels.delete(key);
-            }
-            list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
+            heldModel(room, next);
             if (changed === null)
                 emitRooms();
             else
                 publishChangeSet(changed);
         });
     }
+    function heldModel(room, next) {
+        models.set(room.locator, next);
+        if (next.status === 'current') {
+            liveModels.set(room.locator, JSON.stringify(next.snapshot));
+            invalidModels.delete(room.locator);
+        }
+        list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
+    }
     async function scoped(result, room, local) {
         if (result.scope === 'content' && !result.retryable) {
             journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
@@ -3869,14 +4136,14 @@ export function composeRuntime(options) {
         });
         let scopedAway = room;
         if (result.scope === 'model')
-            await retainModel(local, room, 'collection', {
+            await retainModel(local, room, {
                 status: 'unavailable',
                 reason: 'not-readable',
             });
         else if (result.scope !== 'operation') {
             unreadable.add(room.locator);
             scopedAway = { ...room, replica: { ...room.replica, admission: 'unavailable' } };
-            await retainModel(local, scopedAway, 'collection', modelOf(room.locator));
+            await retainModel(local, scopedAway, modelOf(room.locator));
         }
         if (!continuing())
             return;
@@ -3926,7 +4193,7 @@ export function composeRuntime(options) {
             return false;
         }
         if (prior !== undefined)
-            await retainModel(local, room, 'collection', modelOf(room.locator));
+            await retainModel(local, room, modelOf(room.locator));
         if (discoveryPaused || authorization === undefined)
             return false;
         return room.replica.admission === 'admitted';
@@ -3939,10 +4206,8 @@ export function composeRuntime(options) {
             await withhold(withheld, room, local, progress);
     }
     function revoked(locator) {
-        return ['collection', 'typed-selection'].some((attached) => {
-            const model = modelOf(locator, attached);
-            return model.status === 'unavailable' && model.reason === 'revoked';
-        });
+        const model = modelOf(locator);
+        return model.status === 'unavailable' && model.reason === 'revoked';
     }
     async function loadRoom(room, local, progress, live) {
         if (!live() || authorization === undefined)
@@ -3992,6 +4257,8 @@ export function composeRuntime(options) {
         catch {
             result = { kind: 'transport-uncertainty' };
         }
+        if (result.kind === 'discovery')
+            roomsNamed = true;
         if (!live()) {
             progress.complete = false;
             notifyReady();
@@ -3999,12 +4266,7 @@ export function composeRuntime(options) {
         }
         journal.record(`connection discover ${result.kind}`);
         if (result.kind === 'transport-uncertainty') {
-            for (const room of rooms.values()) {
-                await retainModel(local, room, 'collection', cached(modelOf(room.locator)));
-                if (room.typedSelection !== null) {
-                    await retainModel(local, room, 'typed-selection', cached(modelOf(room.locator, 'typed-selection')));
-                }
-            }
+            await settleModels([...rooms.values()].map((room) => discovered.get(room.locator) ?? room), 'cached', local);
             progress.reachable = false;
             progress.complete = false;
             notifyReady();
@@ -4059,6 +4321,7 @@ export function composeRuntime(options) {
             limits = result.providerLimits;
             await local.fact('providerLimits', limits);
             await local.fact('capabilities', capabilities);
+            conversations.declared();
         }
         const signedIn = result.member ?? null;
         if (JSON.stringify(signedIn) !== JSON.stringify(member)) {
@@ -4116,7 +4379,7 @@ export function composeRuntime(options) {
     function sync(attempt) {
         return task(OPENING_LANE, async (live) => {
             if (!live()) {
-                notifyReady();
+                readyFromStore();
                 return;
             }
             const progress = { complete: true, reachable: true };
@@ -4194,6 +4457,7 @@ export function composeRuntime(options) {
         });
     }
     function closedSocket(revoked, lost) {
+        notifyDiscovered();
         const opened = socketOpen;
         socketOpen = false;
         connectionLost();
@@ -4237,13 +4501,9 @@ export function composeRuntime(options) {
                 const local = await openLocal();
                 const reloaded = await replacing;
                 if (progress.reachable) {
-                    for (const room of discovered.values()) {
-                        if (replicas.has(room.locator) &&
-                            !expired.includes(room.locator) &&
-                            !reloading.includes(room.locator)) {
-                            await confirmModels(room, local);
-                        }
-                    }
+                    await settleModels([...discovered.values()].filter((room) => replicas.has(room.locator) &&
+                        !expired.includes(room.locator) &&
+                        !reloading.includes(room.locator)), 'current', local);
                 }
                 const failed = reloaded.find((outcome) => outcome.status === 'rejected');
                 if (failed !== undefined)
@@ -4284,12 +4544,30 @@ export function composeRuntime(options) {
             return [];
         }
     }
-    async function confirmModels(room, local) {
-        for (const attached of ['collection', 'typed-selection']) {
-            const model = modelOf(room.locator, attached);
-            if (model.status === 'cached') {
-                await retainModel(local, room, attached, { ...model, status: 'current' });
+    async function settleModels(held, status, local) {
+        const owed = (room) => {
+            const model = modelOf(room.locator);
+            return model.status !== 'unavailable' && model.status !== status;
+        };
+        const settled = await exclusive(async () => {
+            if (!continuing())
+                return [];
+            const unchanged = held.filter((room) => owed(room) && !declarationRefusals.has(room.locator) && declaredAsHeld(room));
+            for (const room of unchanged) {
+                const next = { ...modelOf(room.locator), status };
+                const replica = replicas.get(room.locator);
+                if (replica !== undefined)
+                    replicas.set(room.locator, { ...replica, record: { ...replica.record, model: next } });
+                heldModel(room, next);
             }
+            if (unchanged.length > 0)
+                emitRooms();
+            return unchanged;
+        });
+        for (const room of held) {
+            if (settled.includes(room) || !owed(room))
+                continue;
+            await retainModel(local, room, { ...modelOf(room.locator), status });
         }
     }
     function submitLater(locator) {
@@ -4402,8 +4680,6 @@ export function composeRuntime(options) {
                 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)
@@ -4511,6 +4787,7 @@ export function composeRuntime(options) {
         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),
+        ahead,
     };
     function observeStream() {
         const stream = options.adapter.roomStream;
@@ -4523,6 +4800,8 @@ export function composeRuntime(options) {
                 socketOpen = true;
                 connectionLive();
                 generation += 1;
+                for (const admit of installWaiters.splice(0))
+                    admit();
                 reads.opened();
                 conversations.reopened();
                 recovery.resume();
@@ -4542,7 +4821,7 @@ export function composeRuntime(options) {
         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);
+        const entries = await ahead(async () => (await openLocal()).entries(held.record.key, 'confirmed', paths));
         return new Map(entries.flatMap(({ path, revision }) => revision === null ? [] : [[path, revision]]));
     }
     function writesHeld() {
@@ -4613,6 +4892,7 @@ export function composeRuntime(options) {
         if (closed)
             return;
         closed = true;
+        notifyDiscovered();
         if (probing !== null)
             clearInterval(probing);
         for (const resolve of shownWaiters.splice(0))
@@ -4628,6 +4908,7 @@ export function composeRuntime(options) {
         conversations.close();
         void recovery.retire();
         roomListeners.clear();
+        unlistedRooms.clear();
         refusalListeners.clear();
         storageLossListeners.clear();
         statusListeners.clear();
@@ -4653,9 +4934,9 @@ export function composeRuntime(options) {
     observeStream();
     void openLocal().then(() => {
         if (capabilities.length > 0)
-            notifyReady();
+            readyFromStore();
     }, () => {
-        notifyReady();
+        readyFromStore();
     });
     if (options.adapter.roomStream === undefined)
         void sync('unstreamed');
@@ -4806,9 +5087,10 @@ export function composeRuntime(options) {
             return watchReadiness({ target: '', code: 'stored', space: null, search: 'unused' }, null, deliver);
         }
         if (topic === 'rooms') {
-            roomListeners.add(deliver);
-            deliver(listed());
+            unlistedRooms.add(deliver);
+            emitKnownRooms();
             return () => {
+                unlistedRooms.delete(deliver);
                 roomListeners.delete(deliver);
             };
         }
@@ -4862,7 +5144,17 @@ export function composeRuntime(options) {
             return openLocal().then(() => undefined);
         },
         rooms() {
-            return listed();
+            if (closed)
+                return Promise.resolve([]);
+            return new Promise((settle) => {
+                const answer = (value) => {
+                    unlistedRooms.delete(answer);
+                    roomListeners.delete(answer);
+                    settle(value);
+                };
+                unlistedRooms.add(answer);
+                emitKnownRooms();
+            });
         },
         query: ((input) => rowsQuery(planned(input, null))),
         search: (input) => searched(input, null, []),
@@ -4872,7 +5164,7 @@ export function composeRuntime(options) {
                 typedSelection: rooms.get(locator)?.typedSelection === undefined ||
                     rooms.get(locator)?.typedSelection === null
                     ? null
-                    : modelTypes(modelOf(locator, 'typed-selection')),
+                    : modelTypes(builtIn),
             };
         },
         roomDraft: {
@@ -4951,6 +5243,8 @@ export function composeRuntime(options) {
             part: readPart,
             read: readBinaryPath,
             link: linkBinaryPath,
+            show: showBinaryPath,
+            attach: attachBinary,
         },
         async call(name, input) {
             await ready;
@@ -5005,6 +5299,7 @@ export function composeRuntime(options) {
         lockedRooms,
         watchLocks,
         located,
+        room: (locator) => listed().find((one) => one.locator === locator),
     };
     return {
         md,