@agentshouse/mdruntime 0.1.0-c94cfdbdb6f68 → 0.1.0-c95f0f04f2113

package/dist/connection.js

@@ -1,3615 +1,113 @@
-import { attachedModel } 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';
-import { createReadSide } from './read-side.js';
-import { seededResult } from './seed.js';
-import { markdownPath, roomOfKey } from './rows.js';
-import { createSearchIndex, searchPlanOf, } from './search.js';
-import { capped, MAXIMUM_WINDOW } from './windows.js';
-import { bootstrapRoom } from './bootstrap.js';
-import { changeSet, entering, mergeChangeSets } from './change-set.js';
-import { createConversationStore, } from './conversation.js';
-import { queuedFile } from './change.js';
-import { indexReferrers, referencesIndexed, validRoot, } from './collection.js';
-import { runtimeError } from './failure.js';
+import { submitLater, unpair } from './acceptance.js';
+import { invokeAction, called, readConversationHistory, resendLater } from './actions.js';
+import { builtInModel, roomTypesOf } from './attached-model.js';
+import { createConversationStore } from './conversation.js';
+import { refusedForSpace } from './durability.js';
+import { createFigures } from './figures.js';
+import { scheduleCurrency, spaceFreed, start } from './lifecycle.js';
+import { createLiveQueries } from './live.js';
 import { createLog } from './log.js';
-import { binaryRecord } from './binary.js';
-import { absentBinary, binaryAnswer, binaryLinkAnswer, calledResult, failure, historyAnswer, undeclared, UNCERTAIN, } from './outcome.js';
+import { scoped } from './models.js';
+import { open } from './opening.js';
+import { deliverOwedReadiness, filled } from './preparation.js';
+import { answeredPlan, figuresCover, roomTallies } from './queries.js';
+import { readAnswers } from './reads.js';
 import { createRecovery } from './recovery.js';
-import { doorReads } from './reads.js';
-import { refreshRoom } from './refresh.js';
-import { buildBatch, joined, limitedIn, queuedDocuments, requeued, } from './save.js';
-import { applyReturned, compositionOf, confirmedOf, landed, readReclassified, replicaOf, sameMembership, standing, } from './replica.js';
-import { binaryBase, changedParts, changesOf, held, heldFile, joinedDraft, moveTarget, readParts, returnedBy, returnedInto, staleWrite, underneath, withdrawnDrafts, } from './room-draft.js';
-import { same, saving, STARTING, transferring, } from './status.js';
-import { detectStorageLoss, nextGeneration } from './durability.js';
-import { readinessOf, SETTLED_ROOMS, } from './readiness.js';
-import { FencedMap } from './fence.js';
-import { tally } from './shared.js';
-import { inChunks, ROW_WEIGHT, yielded } from './turn.js';
-import { identityTime, roomDraftRevision } from './identity.js';
-import { beneath, normalize } from './paths.js';
-import { openRuntimeStore, } from './store.js';
-import { unconfirmed } from './transfer.js';
-import { governs, holds, narrowed, planReach, } from './reach.js';
-function roomsAlone(plan) {
-    return (plan.reach === null &&
-        plan.root.types === null &&
-        plan.root.where === null &&
-        plan.root.pathPrefix === null &&
-        plan.paths === null &&
-        plan.hop === null &&
-        plan.backlinks === null);
-}
-function within(root, path) {
-    return root === '' || beneath(root, path);
-}
-function declaredSelection(room) {
-    const selection = room.typedSelection;
-    if (selection === undefined)
-        return true;
-    if (!Array.isArray(selection.roots) || selection.roots.length === 0)
-        return false;
-    return selection.roots.every((root, index) => validRoot(root) &&
-        root !== '' &&
-        selection.roots.every((other, at) => at === index || !within(other, root)));
-}
-const OPENING_LANE = 'opening';
-const CONVERSATION_LANE = 'conversations';
-const ROOM_READS = 256;
+import { settle } from './saves.js';
+import { publishChangeSet, show } from './shown.js';
+import { createSocket } from './socket.js';
+import { createStore } from './store.js';
+import { composedRuntime } from './surface.js';
+import { advanced, withhold } from './sync.js';
 const ROOM_ATTEMPTS = 16;
-function operationOf(input) {
-    const operation = input?.operation_id;
-    return typeof operation === 'string' ? operation : null;
-}
-const outside = new Map();
-function outsideOf(roots) {
-    const key = JSON.stringify(roots);
-    const held = outside.get(key);
-    if (held !== undefined)
-        return held;
-    const counted = (path) => (roots.some((root) => beneath(root, path)) ? 0 : 1);
-    const made = {
-        documents: (path) => (markdownPath(path) ? counted(path) : 0),
-        binaries: counted,
-    };
-    outside.set(key, made);
-    return made;
-}
-function abandonedOn(signal) {
-    return new Promise((resolve) => {
-        if (signal.aborted)
-            resolve(null);
-        else
-            signal.addEventListener('abort', () => resolve(null), { once: true });
-    });
-}
-function roomLane(locator) {
-    return `room ${locator}`;
-}
 export function composeRuntime(options) {
-    const localSaves = options.adapter.localSaves === true;
-    let authorization = options.authorization;
-    let opening;
-    let store;
-    const fences = new Map();
-    const isFenced = (locator) => fences.has(locator);
-    let fencings = 0;
-    const lastFenced = new Map();
-    const fencedSince = (locator, since) => fences.has(locator) || (lastFenced.get(locator) ?? 0) > since;
-    let discoveries = 0;
-    const replicas = new FencedMap(isFenced);
-    const queuesWithoutReplica = new FencedMap(isFenced);
-    const pendings = new Map();
-    const seeds = new Map();
-    const seedWatchers = new Map();
-    const roomDrafts = 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 invalidModels = new Set();
-    const discovered = new Map();
-    const reads = doorReads(options.adapter, (locator) => discovered.get(locator), () => generation);
-    let roomsListed = false;
-    const scopedRefusals = new Map();
-    const sourceRefusals = new Map();
-    const declarationRefusals = new Set();
-    function modelKey(locator, attached) {
-        return `${attached} ${locator}`;
-    }
-    function modelOf(locator, attached = 'collection') {
-        return models.get(modelKey(locator, attached)) ?? NO_MODEL;
-    }
-    function savedModel(locator, attached) {
-        return invalidModels.has(modelKey(locator, attached))
-            ? { status: 'unavailable', reason: 'revoked' }
-            : modelOf(locator, attached);
-    }
-    function compositionFor(record) {
-        return compositionOf({
-            ...record,
-            model: savedModel(record.locator, 'collection'),
-            selectionModel: savedModel(record.locator, 'typed-selection'),
-        });
-    }
-    let refusal = null;
-    let storageLoss = null;
-    let status = STARTING;
-    let shown = STARTING;
-    let discoveryPaused = false;
-    let closed = false;
-    let stopping = false;
-    let withdrawStream;
-    const announced = new Map();
-    let underway = null;
-    let streamed = null;
-    let handed = false;
-    const recovery = (options.recovery ?? createRecovery()).scope(ROOM_ATTEMPTS);
-    const repairing = new Set();
-    const calling = new Set();
-    const repairable = new Map();
-    let outcomeRetention = null;
-    const answering = new Map();
-    let complete = false;
-    let recorded = false;
-    const stale = new Set();
-    let generation = 0;
-    let discovering = null;
-    let opened = null;
-    const owed = new Set();
-    const lanes = new Map();
-    let roomReads = { generation, free: ROOM_READS, waiting: [] };
-    const working = new Set();
-    let mutations = Promise.resolve();
-    const roomListeners = new Set();
-    const refusalListeners = new Set();
-    const storageLossListeners = new Set();
-    const statusListeners = new Set();
-    const queueSubscriptions = new Set();
-    const roomDraftListeners = new Set();
-    const presentationListeners = new Set();
-    const readSide = createReadSide();
-    let withdrawConversations;
-    let currencyQueued = null;
-    let socketOpen = false;
-    let serviceMode = 'open';
-    let haltedRefusal = false;
-    let openSignals = 0;
-    const serviceModeListeners = new Set();
-    let member = null;
-    const memberListeners = new Set();
-    const prepared = new Set();
-    const projecting = new Set();
-    const unpreparedDemand = new Set();
-    const unindexable = new Set();
-    let preparing = false;
-    let targets = {};
-    let persistence = options.shell.persistence;
-    let capacity = null;
-    const paused = new Set();
-    let rechecking = null;
-    const readinessWatches = new Set();
-    let readinessQueued = false;
-    const catching = new Set();
-    const transfers = new FencedMap(isFenced);
-    const conversations = createConversationStore({
-        agents: declaredAgents,
-        documents: ({ locator }) => rowsQuery(planOf({ rooms: [locator], select: { fields: 'all' } }, roomFacts())),
-        call: (name, input) => invokeAction(name, input),
-        durably,
-        stream: () => options.adapter.conversations,
-        publish: publishChangeSet,
-        online: () => connectionOf() !== 'unreachable' && refusal === null,
-        closed: () => closed,
-        unanswered: resendLater,
-        expired: (operation) => pastHorizon(operation),
-    });
-    const searchIndex = createSearchIndex({
-        room: (room) => readSide.room(room),
-        document: (room, path) => readSide.document(room, path),
-    });
-    const roomsToIndex = new Set();
-    const conversationsToIndex = new Set();
-    let indexing = false;
+    const { adapter, shell } = options;
+    const roomTypes = roomTypesOf(adapter.roomTypes, adapter.nameableRoomTypes);
+    const builtIn = builtInModel(roomTypes);
+    const typedPaths = adapter.typedPaths ?? [];
     const journal = createLog();
-    let notifyReady = () => { };
-    const ready = new Promise((resolve) => {
-        notifyReady = resolve;
-    });
-    function rememberRoomDraft(record) {
-        const room = roomDrafts.get(record.locator) ?? new Map();
-        room.set(record.path, record);
-        roomDrafts.set(record.locator, room);
-    }
-    function forgetRoomDraft(locator, path) {
-        const room = roomDrafts.get(locator);
-        if (room === undefined)
-            return;
-        room.delete(path);
-        if (room.size === 0)
-            roomDrafts.delete(locator);
-    }
-    function roomDraftOf(record) {
-        return structuredClone({
-            room: record.locator,
-            path: record.path,
-            revision: record.revision,
-            parts: record.parts,
-            changedUnderneath: underneath(record.parts, record.path, replicas.get(record.locator)?.visible),
-            returned: record.returned,
-        });
-    }
-    function snapshotRoomDrafts() {
-        const records = [...roomDrafts.values()].flatMap((room) => [...room.values()]);
-        records.sort((left, right) => {
-            if (left.locator !== right.locator)
-                return left.locator < right.locator ? -1 : 1;
-            if (left.path !== right.path)
-                return left.path < right.path ? -1 : 1;
-            return 0;
-        });
-        return records.map(roomDraftOf);
-    }
-    function publishRoomDrafts(waitingOnly) {
-        if (closed)
-            return;
-        const value = snapshotRoomDrafts();
-        for (const listener of roomDraftListeners) {
-            if (waitingOnly && listener.ready)
-                continue;
-            listener.ready = true;
-            listener.notify(value);
-        }
-    }
-    function presentationOf(app) {
-        const value = presentations.get(app);
-        return value === undefined ? null : structuredClone(value);
-    }
-    function keepPresentation(app, next) {
-        return exclusive(async () => {
-            const local = await openLocal();
-            const stored = next(presentations.get(app));
-            await local.present({ app, value: stored });
-            presentations.set(app, stored);
-            publishChangeSet(changeSet('', null, null, { presentation: app }));
-        });
-    }
-    function emitPresentation(app) {
-        if (closed)
-            return;
-        for (const listener of presentationListeners) {
-            if (listener.app === app && listener.ready)
-                listener.notify(presentationOf(app));
-        }
-    }
-    function pending() {
-        return (!localSaves &&
-            (queuesWithoutReplica.size > 0 ||
-                [...replicas.values()].some((replica) => replica.queue.length > 0)));
-    }
-    function attention() {
-        const attentionRequired = [];
-        for (const record of [...roomDrafts.values()].flatMap((room) => [...room.values()])) {
-            if (record.returned === null)
-                continue;
-            attentionRequired.push({
-                room: record.locator,
-                path: record.path,
-                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;
-        });
-        let reset = null;
-        for (const { submission } of pendings.values()) {
-            if (submission.state !== 'reset')
-                continue;
-            if (reset === null || submission.reset < reset)
-                reset = submission.reset;
-        }
-        return { attentionRequired, reset };
-    }
-    function documentsIn(locator) {
-        const replica = replicas.get(locator);
-        if (replica === undefined)
-            return 0;
-        const roots = replica.confirmed.record.typedSelection?.roots ?? [];
-        const weighed = outsideOf(roots);
-        return (tally(replica.visible.documents, weighed.documents) +
-            tally(replica.visible.binaries, weighed.binaries));
-    }
-    function listed() {
-        return structuredClone([...rooms.values()].map((room) => {
-            const documents = documentsIn(room.locator);
-            counted.set(room.locator, documents);
-            return { ...room, documents };
-        }));
-    }
-    function roomFacts(reach = null) {
-        const held = [...rooms.values()]
-            .filter((room) => holds(reach, room.locator))
-            .map((room) => {
-            const governed = governs(reach, room);
-            const attached = [
-                ...(governed.collection ? [modelOf(room.locator)] : []),
-                ...(governed.selection ? [modelOf(room.locator, 'typed-selection')] : []),
-            ];
-            return {
-                locator: room.locator,
-                available: attached.every((model) => model.status !== 'unavailable'),
-                types: attached.flatMap((model) => model.status === 'unavailable' ? [] : Object.values(model.types)),
-            };
-        });
-        return { listed: roomsListed, rooms: held };
-    }
-    function emitRooms() {
-        readSide.recover();
-        queueReadiness();
-        const value = listed();
-        for (const listener of roomListeners)
-            listener(value);
-    }
-    function emitRefusal() {
-        queueReadiness();
-        for (const listener of refusalListeners)
-            listener(refusal);
-    }
-    function emitStorageLoss() {
-        queueReadiness();
-        for (const listener of storageLossListeners)
-            listener(storageLoss);
-    }
-    function emitMember() {
-        for (const listener of memberListeners)
-            listener(member);
-    }
-    function moveTo(next) {
-        if (closed)
-            return;
-        status = next;
-        show();
-    }
-    function show() {
-        if (closed)
-            return;
-        queueReadiness();
-        const next = status.state === 'synced' && !conversations.current()
-            ? { ...status, state: 'syncing' }
-            : status;
-        if (same(shown, next))
-            return;
-        shown = next;
-        for (const listener of statusListeners)
-            listener(shown);
-    }
-    function entryOf(batch) {
-        if (localSaves)
-            return Object.freeze({ batch, state: 'local' });
-        const state = pendings.get(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) {
-        return (replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? []).map(entryOf);
-    }
-    function emitQueue(locator) {
-        const entries = entriesOf(locator);
-        for (const subscription of queueSubscriptions) {
-            if (subscription.locator === locator)
-                subscription.notify(entries);
-        }
-    }
-    function applyChangeSet(set) {
-        const held = {
-            ...set,
-            documents: set.documents.filter(({ locator }) => prepared.has(locator) || projecting.has(locator)),
-        };
-        const applied = readSide.apply(held, () => searchIndex.changed(held));
-        if (applied instanceof Promise)
-            void applied.catch(unpublished);
-    }
-    function unpublished(error) {
-        journal.record(`publication failed ${error instanceof Error ? error.name : 'unknown'}`);
-    }
-    async function referenced(locator) {
-        for (;;) {
-            const record = replicas.get(locator)?.confirmed.record;
-            if (record === undefined || closed)
-                return;
-            const held = { text: record.documents, binaries: record.binaries };
-            const composition = compositionOf(record);
-            if (referencesIndexed(held, composition))
-                return;
-            await indexReferrers(held, composition);
-        }
-    }
-    async function prepareReplica(locator) {
-        await referenced(locator);
-        const replica = replicas.get(locator);
-        if (replica === undefined || closed || prepared.has(locator))
-            return;
-        const visible = replica.visible;
-        const paths = [
-            ...new Set([...Object.keys(visible.documents), ...Object.keys(visible.binaries)]),
-        ];
-        const entered = [];
-        projecting.add(locator);
-        try {
-            await inChunks(paths, (path) => ROW_WEIGHT + (visible.documents[path]?.length ?? 0), (chunk) => {
-                const current = replicas.get(locator);
-                if (current === undefined || closed)
-                    return;
-                const set = entering(locator, current, chunk);
-                entered.push(set);
-                return readSide.apply(set);
-            });
-            if (!replicas.has(locator) || closed)
-                return;
-            prepared.add(locator);
-        }
-        finally {
-            projecting.delete(locator);
-        }
-        conversations.changed(mergeChangeSets(entered));
-        readSide.recover();
-        queueReadiness();
-    }
-    function unprepared() {
-        return [...unpreparedDemand, ...replicas.keys()].find((locator) => !prepared.has(locator) && !unindexable.has(locator));
-    }
-    function unbuilt(locator, error) {
-        unindexable.add(locator);
-        journal.record(`index failed ${locator} ${error instanceof Error ? error.name : 'unknown'}`);
-        queueReadiness();
-    }
-    function prepare(locators = []) {
-        for (const locator of locators)
-            unpreparedDemand.add(locator);
-        if (preparing)
-            return;
-        preparing = true;
-        void (async () => {
-            try {
-                for (let waiting = unprepared(); waiting !== undefined; waiting = unprepared()) {
-                    await yielded();
-                    if (closed)
-                        return;
-                    unpreparedDemand.delete(waiting);
-                    await prepareReplica(waiting).catch((error) => unbuilt(waiting, error));
-                }
-            }
-            finally {
-                preparing = false;
-            }
-        })();
-    }
-    function reachedRooms(plan) {
-        const reach = plan.reach;
-        const reached = reach === null ? null : new Set([...reach.rooms, ...reach.documents.map(roomOfKey)]);
-        const named = plan.rooms ??
-            (reached === null
-                ? [...new Set([...rooms.keys(), ...replicas.keys(), ...queuesWithoutReplica.keys()])]
-                : [...reached]);
-        return [...new Set(named)].filter((locator) => reached === null || reached.has(locator)).sort();
-    }
-    function awaited(locator) {
-        return (!roomsListed ||
-            (rooms.has(locator) && discovered.get(locator)?.replica.admission === 'admitted'));
-    }
-    function covered(plan) {
-        const locators = reachedRooms(plan);
-        if (locators.length === 0 && plan.rooms === null && plan.reach === null && !roomsListed) {
-            return { pending: [] };
-        }
-        const pending = [];
-        const coverage = [];
-        const overlay = [];
-        for (const locator of locators) {
-            const replica = replicas.get(locator);
-            if (replica === undefined) {
-                if (awaited(locator))
-                    pending.push({ room: locator, awaits: 'acquisition' });
-                continue;
-            }
-            if (!prepared.has(locator)) {
-                pending.push({ room: locator, awaits: 'preparation' });
-                continue;
-            }
-            coverage.push({
-                room: locator,
-                generation: replica.confirmed.record.transfer,
-                current: !(catching.has(locator) || owed.has(locator) || transfers.has(locator)),
-            });
-            for (const batch of replica.queue)
-                overlay.push(batch.id);
-        }
-        if (pending.length > 0)
-            return { pending };
-        return { coverage: { rooms: coverage, indexes: [], overlay } };
-    }
-    function awaitPreparation(cover) {
-        if (!('pending' in cover))
-            return;
-        const waiting = cover.pending.filter(({ awaits }) => awaits === 'preparation');
-        if (waiting.length > 0)
-            prepare(waiting.map(({ room }) => room));
-    }
-    function requiredRooms(reach) {
-        if (reach === null)
-            return { listed: roomsListed, rooms: [...rooms.keys()].sort() };
-        const named = [...new Set(reach.rooms)].sort();
-        if (roomsListed)
-            return { listed: true, rooms: named.filter((room) => rooms.has(room)) };
-        return { listed: named.every((room) => replicas.has(room)), rooms: named };
-    }
-    function roomState(locator, search) {
-        if (sourceRefusals.has(locator))
-            return 'refused';
-        const listedRoom = discovered.get(locator);
-        if (roomsListed &&
-            (listedRoom === undefined ||
-                listedRoom.replica.admission !== 'admitted' ||
-                unreadable.has(locator)))
-            return 'unadmitted';
-        if (!replicas.has(locator))
-            return 'acquiring';
-        if (!prepared.has(locator))
-            return 'preparing';
-        if (search && !searchIndex.rooms().has(locator))
-            return 'indexing';
-        return 'complete';
-    }
-    function conversationCoverage(reach, search) {
-        const declared = reach === null || reach.conversations;
-        if (!declared || options.adapter.conversations === undefined || declaredAgents() === undefined)
-            return 'undeclared';
-        if (!conversations.known() || !conversations.current())
-            return 'acquiring';
-        if (!search)
-            return 'complete';
-        const unindexed = conversations
-            .searchable()
-            .filter((one) => conversations.acquired(one) && !searchIndex.conversations().has(one));
-        if (unindexed.length === 0)
-            return 'complete';
-        index([], unindexed);
-        return 'indexing';
-    }
-    function connectionOf() {
-        if (socketOpen)
-            return 'connected';
-        if (status.providerUnreachable)
-            return 'unreachable';
-        return options.adapter.roomStream === undefined && status.lastCompleted !== null
-            ? 'connected'
-            : 'connecting';
-    }
-    function refusedIn(locators) {
-        return locators.flatMap((room) => {
-            const held = sourceRefusals.get(room);
-            if (held === undefined)
-                return [];
-            const { file, location } = held.fields;
-            return [
-                {
-                    room,
-                    file: typeof file === 'string' ? file : '',
-                    rule: held.code,
-                    location: typeof location === 'string' ? location : null,
-                },
-            ];
-        });
-    }
-    function readinessFor(port, reach) {
-        const required = requiredRooms(reach);
-        const search = port.search === 'required';
-        const coverage = required.rooms.map((room) => ({ room, state: roomState(room, search) }));
-        const building = (state) => coverage
-            .filter((room) => room.state === state && !unindexable.has(room.room))
-            .map(({ room }) => room);
-        const preparing = building('preparing');
-        if (preparing.length > 0)
-            prepare(preparing);
-        const indexing = building('indexing');
-        if (indexing.length > 0)
-            index(indexing, []);
-        return readinessOf({
-            code: port.code,
-            coverage: {
-                listed: required.listed,
-                rooms: coverage,
-                conversations: conversationCoverage(reach, search),
-                search: search ? 'required' : 'unused',
-            },
-            persistence,
-            connection: connectionOf(),
-            house: refusal !== null ? 'refused' : writesHeld() ? 'write-halted' : 'open',
-            capacity: capacity !== null &&
-                coverage.some(({ room, state }) => paused.has(room) || !SETTLED_ROOMS.has(state))
-                ? capacity
-                : port.capacity,
-            refused: refusedIn(required.rooms),
-            lost: storageLoss !== null,
-            established: targets[port.target]?.established === true,
-        });
-    }
-    function establish(name) {
-        targets = { ...targets, [name]: { established: true } };
-        queueReadiness();
-        void durably((local) => local.keepTargets(targets)).catch(() => {
-            journal.record(`target record failed ${name}`);
-        });
-    }
-    function deliverReadiness(watch) {
-        if (!readinessWatches.has(watch))
-            return;
-        const readiness = readinessFor(watch.port, watch.reach);
-        if (readiness.ready && targets[watch.port.target]?.established !== true) {
-            establish(watch.port.target);
-        }
-        const shown = JSON.stringify(readiness);
-        if (shown === watch.last)
-            return;
-        watch.last = shown;
-        watch.deliver(structuredClone(readiness));
-    }
-    function queueReadiness() {
-        if (readinessQueued || closed || readinessWatches.size === 0)
-            return;
-        readinessQueued = true;
-        queueMicrotask(() => {
-            readinessQueued = false;
-            if (closed)
-                return;
-            for (const watch of [...readinessWatches])
-                deliverReadiness(watch);
-        });
-    }
-    function watchReadiness(port, reach, deliver) {
-        const watch = { port, reach, deliver, last: null };
-        readinessWatches.add(watch);
-        void openLocal().then(() => deliverReadiness(watch), () => deliverReadiness(watch));
-        return () => {
-            readinessWatches.delete(watch);
-        };
-    }
-    function layerBytes(layer) {
-        let bytes = 0;
-        for (const [path, text] of Object.entries(layer.documents))
-            bytes += (path.length + text.length) * 2;
-        return bytes;
-    }
-    function grownBy(next, previous) {
-        if (previous === undefined)
-            return layerBytes(next);
-        const documents = Object.fromEntries(Object.entries(next.documents).filter(([path, text]) => previous.documents[path] !== text));
-        return layerBytes({ ...next, documents });
-    }
-    function exceeded(error) {
-        return (typeof error === 'object' &&
-            error !== null &&
-            error.name === 'QuotaExceededError');
-    }
-    async function estimated() {
-        const estimate = options.shell.estimate === undefined ? null : await options.shell.estimate();
-        return estimate === null ? null : Math.max(0, estimate.quota - estimate.usage);
-    }
-    function pause(locator, cause) {
-        paused.add(locator);
-        capacity = cause;
-        journal.record(`capacity ${cause.cause} ${locator} ${cause.needed} ${cause.available ?? '-'}`);
-        queueReadiness();
-        if (rechecking !== null)
-            return;
-        // A paused preparation measures the browser's space again each minute, so space freed elsewhere resumes it without a retry.
-        rechecking = setInterval(() => {
-            void recheck();
-        }, 60_000);
-    }
-    async function recheck() {
-        const held = capacity;
-        if (held === null || closed)
-            return;
-        const available = await estimated().catch(() => null);
-        if (available === null || available < (held.needed ?? 0))
-            return;
-        if (held.cause === 'quota-exceeded' && (held.available === null || available <= held.available))
-            return;
-        resume();
-    }
-    function resume() {
-        if (rechecking !== null)
-            clearInterval(rechecking);
-        rechecking = null;
-        if (paused.size === 0 && capacity === null)
-            return;
-        paused.clear();
-        capacity = null;
-        journal.record('capacity resumed');
-        queueReadiness();
-        if (!closed && authorization !== undefined)
-            void sync('unstreamed');
-    }
-    async function reclaimed(local) {
-        const unreferenced = [...transfers.keys()].filter((locator) => !discovered.has(locator));
-        for (const locator of unreferenced) {
-            await local.abandon(locator);
-            transfers.delete(locator);
-        }
-        if (unreferenced.length > 0)
-            journal.record(`capacity reclaimed ${unreferenced.length}`);
-        return unreferenced.length > 0;
-    }
-    async function admitted(local, locator, needed) {
-        if (paused.has(locator))
-            return false;
-        let available = await estimated().catch(() => null);
-        if (available === null || available >= needed)
-            return true;
-        if (await reclaimed(local))
-            available = await estimated().catch(() => null);
-        if (available === null || available >= needed)
-            return true;
-        pause(locator, { cause: 'insufficient-space', needed, available });
-        return false;
-    }
-    async function exceededOn(locator, bytes) {
-        const available = await estimated().catch(() => null);
-        pause(locator, { cause: 'quota-exceeded', needed: bytes, available });
-    }
-    function seedRoomHeld(room, version) {
-        return prepared.has(room) && reachedBy(room, version);
-    }
-    function seedHeld(at) {
-        return Object.entries(at).every(([room, version]) => (roomsListed && !rooms.has(room)) || seedRoomHeld(room, version));
-    }
-    function seedApplies(plan) {
-        const seed = seeds.get(plan.key);
-        if (seed === undefined)
-            return null;
-        if (!seedHeld(seed.at))
-            return seed;
-        seeds.delete(plan.key);
-        return null;
-    }
-    function seedBehind(plan, cover) {
-        const seed = seedApplies(plan);
-        if (seed === null || 'pending' in cover)
-            return cover;
-        return {
-            pending: Object.entries(seed.at)
-                .filter(([room, version]) => !seedRoomHeld(room, version))
-                .map(([room]) => ({ room, awaits: 'acquisition' })),
-        };
-    }
-    function seed(entry) {
-        if (seedHeld(entry.at))
-            return;
-        for (const { query, rows } of entry.queries) {
-            const key = queryKey(query);
-            seeds.set(key, { rows, at: entry.at });
-            for (const shown of seedWatchers.get(key) ?? [])
-                shown();
-        }
-    }
-    async function rowsQuery(plan) {
-        const before = covered(plan);
-        awaitPreparation(before);
-        const seeded = seedApplies(plan);
-        if (seeded !== null)
-            return seededResult(seeded).result;
-        if ('pending' in before)
-            return before;
-        const { rows, at: cover } = await readSide.query(plan, () => covered(plan));
-        awaitPreparation(cover);
-        if ('pending' in cover)
-            return cover;
-        return { ...rows, coverage: cover.coverage };
-    }
-    async function indexConversation(conversation) {
-        searchIndex.indexMessages(conversation, [], false);
-        let after = null;
-        for (;;) {
-            const batch = await durably((local) => local.messagesAfter(conversation, after));
-            if (closed)
-                return;
-            searchIndex.indexMessages(conversation, batch.map(({ identity, text }) => ({ conversation, identity, text })), batch.length === 0);
-            if (batch.length === 0)
-                return;
-            after = batch[batch.length - 1].identity;
-        }
-    }
-    function indexNext() {
-        const room = [...roomsToIndex].find((locator) => !searchIndex.rooms().has(locator) && !unindexable.has(locator));
-        if (room !== undefined) {
-            roomsToIndex.delete(room);
-            return () => prepared.has(room)
-                ? searchIndex.indexRoom(room).catch((error) => unbuilt(room, error))
-                : undefined;
-        }
-        const conversation = [...conversationsToIndex].find((one) => !searchIndex.conversations().has(one));
-        if (conversation === undefined)
-            return null;
-        conversationsToIndex.delete(conversation);
-        return () => indexConversation(conversation);
-    }
-    function index(rooms, named) {
-        for (const room of rooms)
-            roomsToIndex.add(room);
-        for (const conversation of named)
-            conversationsToIndex.add(conversation);
-        if (indexing)
-            return;
-        indexing = true;
-        void (async () => {
-            try {
-                for (let unit = indexNext(); unit !== null && !closed; unit = indexNext()) {
-                    await yielded();
-                    await unit();
-                    queueReadiness();
-                }
-            }
-            finally {
-                indexing = false;
-            }
-        })().catch(() => { });
-    }
-    function publishChangeSet(set) {
-        applyChangeSet(set);
-        if (set.rooms.length > 0 ||
-            [...new Set(set.documents.map(({ locator }) => locator))].some((locator) => rooms.has(locator) && counted.get(locator) !== documentsIn(locator)))
-            emitRooms();
-        for (const locator of set.queues)
-            emitQueue(locator);
-        if (set.drafts.length > 0 ||
-            set.documents.some((change) => roomDrafts.get(change.locator)?.has(change.path) === true)) {
-            publishRoomDrafts(false);
-        }
-        for (const app of set.presentations)
-            emitPresentation(app);
-        conversations.changed(set);
-    }
-    async function refuse(reason, provider = null) {
-        discoveryPaused = true;
-        try {
-            if (reason === 'revoked-authorization') {
-                await exclusive(async () => {
-                    const revoked = { status: 'unavailable', reason: 'revoked' };
-                    try {
-                        const local = await openLocal();
-                        await local.revokeModels([...replicas.values()].map((replica) => replica.confirmed.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'));
-                    }
-                    for (const key of keys) {
-                        invalidModels.add(key);
-                        models.set(key, revoked);
-                        liveModels.delete(key);
-                    }
-                    const changed = [];
-                    for (const [locator, room] of rooms) {
-                        const before = replicas.get(locator) ?? null;
-                        if (before !== null) {
-                            const record = {
-                                ...before.confirmed.record,
-                                model: revoked,
-                                selectionModel: revoked,
-                            };
-                            replicas.set(locator, replicaOf(confirmedOf(record, before.confirmed), before.queue, before));
-                        }
-                        rooms.set(locator, {
-                            ...room,
-                            model: modelTypes(revoked),
-                            typedSelection: room.typedSelection === null
-                                ? null
-                                : { ...room.typedSelection, model: modelTypes(revoked) },
-                        });
-                        changed.push(changeSet(locator, before, replicas.get(locator) ?? null, { room: true }));
-                    }
-                    publishChangeSet(mergeChangeSets(changed));
-                });
-            }
-        }
-        finally {
-            refusal = {
-                code: reason,
-                retryable: false,
-                reauthorizationOffered: reason === 'revoked-authorization',
-                refusal: provider,
-            };
-            journal.record(`connection refused ${reason}`);
-            emitRefusal();
-        }
-    }
-    function list(room, synchronizationAvailable) {
-        const selection = room.typedSelection ?? null;
-        rooms.set(room.locator, {
-            name: room.name,
-            locator: room.locator,
-            handle: room.handle,
-            operations: room.operations,
-            replica: room.replica,
-            model: modelTypes(modelOf(room.locator)),
-            typedSelection: selection === null
-                ? null
-                : {
-                    roots: selection.roots,
-                    model: modelTypes(modelOf(room.locator, 'typed-selection')),
-                },
-            providerOwnedPaths: room.providerOwnedPaths,
-            roomVersion: replicas.get(room.locator)?.confirmed.record.roomVersion ?? null,
-            synchronizationAvailable,
-            refusal: scopedRefusals.get(room.locator) ?? sourceRefusals.get(room.locator) ?? null,
-        });
-    }
-    async function applyDiscovery(found, started, covered) {
-        for (const room of found) {
-            const fence = fences.get(room.locator);
-            if (fence !== undefined && fence.erased && fence.at < started)
-                fences.delete(room.locator);
-        }
-        await loseRooms(found
-            .filter((room) => room.replica.admission !== 'admitted' && heldLocally(room.locator))
-            .map((room) => room.locator));
-        const listed = found.filter((room) => !fences.has(room.locator));
-        const listedLocators = new Set(listed.map((room) => room.locator));
-        for (const locator of listedLocators)
-            scopedRefusals.delete(locator);
-        if (covered === undefined)
-            discovered.clear();
-        else
-            for (const locator of covered)
-                discovered.delete(locator);
-        for (const room of listed)
-            discovered.set(room.locator, room);
-        const unlisted = unlistedHeld(new Set(found.map((room) => room.locator))).filter((locator) => covered === undefined || covered.includes(locator));
-        if (options.adapter.exhaustiveDiscovery === true)
-            await loseRooms(unlisted);
-        else
-            unlistedKept(unlisted);
-        for (const room of listed) {
-            const held = replicas.get(room.locator)?.confirmed.record;
-            if (held !== undefined && held.replica.selection !== room.replica.selection) {
-                list(held, false);
-                continue;
-            }
-            list(room, room.replica.admission === 'admitted' && !unreadable.has(room.locator));
-        }
-        roomsListed = true;
-        emitRooms();
-        return listed;
-    }
-    function heldLocally(locator) {
-        return (replicas.has(locator) ||
-            roomDrafts.has(locator) ||
-            transfers.has(locator) ||
-            queuesWithoutReplica.has(locator));
-    }
-    function unlistedHeld(listed) {
-        return [
-            ...new Set([
-                ...rooms.keys(),
-                ...roomDrafts.keys(),
-                ...transfers.keys(),
-                ...queuesWithoutReplica.keys(),
-            ]),
-        ].filter((locator) => !listed.has(locator));
-    }
-    function unlistedKept(unlisted) {
-        for (const locator of unlisted) {
-            const held = replicas.get(locator)?.confirmed.record;
-            if (held !== undefined)
-                list(held, false);
-            else
-                rooms.delete(locator);
-        }
-    }
-    function fence(locators) {
-        const fresh = [...new Set(locators)].filter((locator) => !fences.has(locator));
-        const removed = fresh.map((locator) => changeSet(locator, replicas.get(locator) ?? null, null, {
-            room: true,
-            queue: true,
-            drafts: [...(roomDrafts.get(locator)?.keys() ?? [])],
-        }));
-        for (const locator of fresh) {
-            fences.set(locator, { at: discoveries, erased: false });
-            lastFenced.set(locator, ++fencings);
-            for (const batch of replicas.get(locator)?.queue ?? queuesWithoutReplica.get(locator) ?? [])
-                pendings.delete(batch.id);
-            replicas.delete(locator);
-            queuesWithoutReplica.delete(locator);
-            rooms.delete(locator);
-            roomDrafts.delete(locator);
-            transfers.delete(locator);
-            catching.delete(locator);
-            discovered.delete(locator);
-            announced.delete(locator);
-            unreadable.delete(locator);
-            stale.delete(locator);
-            repairable.delete(locator);
-            unindexable.delete(locator);
-            paused.delete(locator);
-            scopedRefusals.delete(locator);
-            sourceRefusals.delete(locator);
-            declarationRefusals.delete(locator);
-            for (const attached of ['collection', 'typed-selection']) {
-                const key = modelKey(locator, attached);
-                models.delete(key);
-                liveModels.delete(key);
-                invalidModels.delete(key);
-            }
-            journal.record(`room lost ${locator}`);
-        }
-        if (fresh.length === 0)
-            return fresh;
-        publishChangeSet(mergeChangeSets(removed));
-        for (const locator of fresh)
-            prepared.delete(locator);
-        searchIndex.forget(fresh);
-        readSide.recover();
-        moveTo({ ...status, ...attention() });
-        return fresh;
-    }
-    async function erased(local, locators) {
-        await local.erase(locators);
-        for (const locator of locators) {
-            const held = fences.get(locator);
-            if (held !== undefined)
-                held.erased = true;
-        }
-    }
-    async function loseRooms(locators) {
-        const fresh = fence(locators);
-        if (fresh.length > 0)
-            await durably((local) => erased(local, fresh));
-    }
-    function restored(key, persisted) {
-        const prior = models.get(key);
-        if (prior !== undefined &&
-            prior.status !== 'unavailable' &&
-            (persisted.status === 'unavailable' || !sameModel(prior.snapshot, persisted.snapshot))) {
-            invalidModels.add(key);
-        }
-        const model = persisted.status === 'unavailable' ||
-            liveModels.get(key) === JSON.stringify(persisted.snapshot)
-            ? persisted
-            : cached(persisted);
-        models.set(key, model);
-        if (model.status === 'unavailable') {
-            liveModels.delete(key);
-            invalidModels.delete(key);
-        }
-        return model;
-    }
-    async function hydrate(opened) {
-        const [records, queues, kept, presented, held, chatDrafts, lastCompleted, declared, named, known, staged, heldTargets,] = await Promise.all([
-            opened.all(),
-            opened.queues(),
-            opened.roomDrafts(),
-            opened.presentation(),
-            opened.conversations(),
-            opened.chatDrafts(),
-            opened.lastCompleted(),
-            opened.providerLimits(),
-            opened.capabilities(),
-            opened.member(),
-            opened.transfers(),
-            opened.targets(),
-        ]);
-        targets = heldTargets;
-        transfers.clear();
-        for (const record of staged)
-            transfers.set(record.locator, record);
-        limits = declared;
-        capabilities = named;
-        member = known;
-        roomDrafts.clear();
-        for (const record of kept)
-            rememberRoomDraft(record);
-        presentations.clear();
-        for (const record of presented)
-            presentations.set(record.app, record.value);
-        conversations.hydrate(held, chatDrafts);
-        const queuedBatches = new Map(queues.map((queue) => [queue.locator, queue.pending.map(({ batch }) => batch)]));
-        pendings.clear();
-        for (const queue of queues) {
-            for (const { batch, state } of queue.pending)
-                pendings.set(batch.id, state);
-        }
-        const previousReplicas = new Map(replicas);
-        replicas.clear();
-        queuesWithoutReplica.clear();
-        const replicated = new Set(records.map((record) => record.locator));
-        for (const [locator, queue] of queuedBatches) {
-            if (!replicated.has(locator))
-                queuesWithoutReplica.set(locator, queue);
-        }
-        for (const record of records) {
-            const model = restored(modelKey(record.locator, 'collection'), record.model);
-            const selectionModel = restored(modelKey(record.locator, 'typed-selection'), record.selectionModel);
-            const prior = previousReplicas.get(record.locator);
-            const confirmed = confirmedOf({ ...record, model, selectionModel }, prior?.confirmed);
-            replicas.set(record.locator, replicaOf(confirmed, queuedBatches.get(record.locator) ?? [], prior));
-            const existing = rooms.get(record.locator);
-            if (existing === undefined)
-                list(record, false);
-            else {
-                rooms.set(record.locator, {
-                    ...existing,
-                    roomVersion: record.roomVersion,
-                    operations: record.operations,
-                    replica: record.replica,
-                    model: modelTypes(model),
-                    typedSelection: record.typedSelection === null
-                        ? null
-                        : {
-                            roots: record.typedSelection.roots,
-                            model: modelTypes(selectionModel),
-                        },
-                });
-            }
-        }
-        return {
-            lastCompleted,
-            locators: new Set([...queuedBatches.keys(), ...replicas.keys()]),
-            read: mergeChangeSets([...new Set([...previousReplicas.keys(), ...replicas.keys()])].map((locator) => changeSet(locator, previousReplicas.get(locator) ?? null, replicas.get(locator) ?? null))),
-        };
-    }
-    async function readState(opened) {
-        const { lastCompleted, locators, read } = await hydrate(opened);
-        applyChangeSet(read);
-        prepare();
-        if (replicas.size > 0)
-            emitRooms();
-        if (member !== null)
-            emitMember();
-        for (const locator of locators)
-            emitQueue(locator);
-        publishRoomDrafts(false);
-        return lastCompleted;
-    }
-    async function open() {
-        if (closed)
-            throw new Error('runtime closed');
-        const opened = await openRuntimeStore(isFenced);
-        store = opened;
-        const interrupted = await opened.fences();
-        for (const locator of interrupted) {
-            fences.set(locator, { at: discoveries, erased: false });
-            lastFenced.set(locator, ++fencings);
-        }
-        const kept = options.shell.generation;
-        const storedGeneration = await opened.generation();
-        const loss = detectStorageLoss(storedGeneration, kept);
-        const generation = nextGeneration(storedGeneration, kept);
-        if (generation !== storedGeneration)
-            await opened.rememberGeneration(generation);
-        if (generation !== kept)
-            await options.shell.keepGeneration(generation);
-        if (loss !== null) {
-            storageLoss = loss;
-            emitStorageLoss();
-        }
-        const lastCompleted = await readState(opened);
-        if (interrupted.length > 0)
-            await erased(opened, interrupted);
-        moveTo({ ...status, lastCompleted, ...attention() });
-        return opened;
-    }
-    function durably(work) {
-        return exclusive(async () => {
-            const local = await openLocal();
-            return work(local);
-        });
-    }
-    function openLocal() {
-        opening ??= open().catch((error) => {
-            opening = undefined;
-            throw error;
-        });
-        return opening;
-    }
-    function exclusive(work) {
-        const next = mutations.then(work, work);
-        mutations = next.then(() => undefined, () => undefined);
-        return next;
-    }
-    function withdrawable(batch) {
-        const state = pendings.get(batch.id);
-        return state !== undefined && state.submission.state !== 'submitted' && !state.lost;
-    }
-    async function settle(local, locator, before, confirmed, queue, settling = {}) {
-        const previousQueue = before?.queue ?? queuesWithoutReplica.get(locator) ?? [];
-        const { withdrawn, kept } = standing(confirmed, queue, withdrawable, localSaves);
-        const founded = kept.filter((batch) => !queue.includes(batch));
-        const queueChanged = kept.length !== previousQueue.length || founded.length > 0;
-        const unqueued = withdrawn.map((batch) => ({
-            batch,
-            returned: localSaves || landed(batch, confirmed) ? null : returnedBy('withdrawn'),
-        }));
-        const returning = [
-            ...[...unqueued].reverse(),
-            ...(settling.leaving === undefined ? [] : [settling.leaving]),
-        ];
-        const written = new Map();
-        for (const { batch, returned } of returning) {
-            if (returned === null)
-                continue;
-            for (const saved of pendings.get(batch.id)?.drafts ?? []) {
-                const existing = written.get(saved.path) ?? roomDrafts.get(locator)?.get(saved.path);
-                written.set(saved.path, {
-                    locator,
-                    path: saved.path,
-                    revision: roomDraftRevision(),
-                    parts: returnedInto(existing?.parts, saved.parts),
-                    returned,
-                });
-            }
-        }
-        await local.keepAuthored({ locator, queue: kept, founded, roomDrafts: [...written.values()] });
-        const staying = new Set(kept.map((batch) => batch.id));
-        for (const batch of previousQueue) {
-            if (!staying.has(batch.id))
-                pendings.delete(batch.id);
-        }
-        for (const record of written.values())
-            rememberRoomDraft(record);
-        try {
-            await local.write({
-                next: confirmed.record,
-                previous: before?.confirmed.record ?? null,
-                ...(settling.stored === undefined ? {} : { stored: settling.stored }),
-            });
-        }
-        catch (error) {
-            const held = before === undefined ? null : replicaOf(before.confirmed, kept, before);
-            if (held !== null)
-                replicas.set(locator, held);
-            else if (kept.length > 0)
-                queuesWithoutReplica.set(locator, kept);
-            else
-                queuesWithoutReplica.delete(locator);
-            publishChangeSet(changeSet(locator, before ?? null, held, {
-                queue: queueChanged,
-                drafts: [...written.keys()],
-            }));
-            moveTo({ ...status, ...attention() });
-            throw error;
-        }
-        return () => {
-            queuesWithoutReplica.delete(locator);
-            for (const { batch, returned } of unqueued) {
-                const outcome = localSaves ? 'dropped' : returned === null ? 'landed' : 'withdrawn';
-                journal.record(`outcome ${locator} ${batch.id} ${outcome}`);
-            }
-            replicas.set(locator, replicaOf(confirmed, kept, before));
-            return changeSet(locator, before ?? null, replicas.get(locator) ?? null, {
-                room: settling.room,
-                queue: queueChanged,
-                drafts: [...written.keys()],
-            });
-        };
-    }
-    function adoptModels(locator, record) {
-        for (const [attached, model] of [
-            ['collection', record.model],
-            ['typed-selection', record.selectionModel],
-        ]) {
-            const key = modelKey(locator, attached);
-            models.set(key, model);
-            invalidModels.delete(key);
-            if (model.status === 'current')
-                liveModels.set(key, JSON.stringify(model.snapshot));
-            else if (model.status === 'unavailable')
-                liveModels.delete(key);
-        }
-    }
-    function remodel(locator, answers, held) {
-        const taken = (answer, previous, attached) => {
-            if (answer === undefined)
-                return previous;
-            const { state, refused } = attachedModel(answer, previous);
-            if (refused !== null) {
-                const where = refused.location === undefined ? '' : ` ${refused.location}`;
-                journal.record(`model invalid ${locator} ${attached} ${refused.identity} ${refused.rule}${where}`);
-            }
-            models.set(modelKey(locator, attached), state);
-            return state;
-        };
-        return {
-            collection: taken(answers?.collection, held.collection, 'collection'),
-            selection: taken(answers?.selection, held.selection, 'typed-selection'),
-        };
-    }
-    function publish(local, room, confirmed, landing, live) {
-        const { base, stored } = landing;
-        return exclusive(async () => {
-            if (stored !== undefined) {
-                await indexReferrers({ text: confirmed.record.documents, binaries: confirmed.record.binaries }, compositionOf(confirmed.record));
-            }
-            if (!live()) {
-                caughtUpTo(room.locator);
-                return true;
-            }
-            const prior = replicas.get(room.locator);
-            if (base !== undefined &&
-                (prior?.confirmed.record.roomVersion !== base.record.roomVersion ||
-                    prior.confirmed.record.revisions !== base.record.revisions)) {
-                return false;
-            }
-            adoptModels(room.locator, confirmed.record);
-            const queue = prior?.queue ?? queuesWithoutReplica.get(room.locator) ?? [];
-            const roomVersion = confirmed.record.roomVersion;
-            const accepted = queue.filter((batch) => {
-                const accepted = pendings.get(batch.id)?.accepted;
-                return (accepted !== undefined && options.adapter.reached(room.locator, roomVersion, accepted));
-            });
-            let settled;
-            try {
-                settled = await settle(local, room.locator, prior, confirmed, queue.filter((batch) => !accepted.includes(batch)), { room: true, ...(stored === undefined ? {} : { stored }) });
-            }
-            catch (error) {
-                if (!exceeded(error))
-                    throw error;
-                await exceededOn(room.locator, grownBy(confirmed.record, prior?.confirmed.record));
-                caughtUpTo(room.locator);
-                return true;
-            }
-            const set = settled();
-            if (stored !== undefined) {
-                transfers.delete(room.locator);
-                catching.delete(room.locator);
-            }
-            for (const batch of accepted)
-                pendings.delete(batch.id);
-            stale.delete(room.locator);
-            unindexable.delete(room.locator);
-            if (unreadable.delete(room.locator))
-                scopedRefusals.delete(room.locator);
-            sourceRefusals.delete(room.locator);
-            declarationRefusals.delete(room.locator);
-            list(room, true);
-            if (prior === undefined)
-                prepared.add(room.locator);
-            publishChangeSet(set);
-            moveTo({ ...status, ...attention() });
-            options.adapter.roomStream?.published(room.locator, roomVersion);
-            return true;
-        });
-    }
-    async function savedRoom(locator) {
-        const local = await openLocal();
-        await referenced(locator);
-        const replica = replicas.get(locator);
-        const room = rooms.get(locator);
-        if (replica === undefined || room === undefined) {
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
-        }
-        return { local, replica, room };
-    }
-    async function saveRoomDrafts(locator, named, writtenBy) {
-        const target = await savedRoom(locator);
-        const saved = [];
-        for (const { path, revision } of named) {
-            const record = roomDrafts.get(locator)?.get(path);
-            if (record === undefined || record.revision !== revision) {
-                return { outcome: 'refused', code: 'stale', retryable: false, file: path };
-            }
-            if (!saved.some((draft) => draft.path === path))
-                saved.push({ path, parts: record.parts });
-        }
-        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 target = await savedRoom(locator);
-        const saved = [];
-        for (const { path, parts } of read) {
-            const file = parts.file === undefined
-                ? undefined
-                : await heldFile(parts.file.blob, binaryBase(target.replica.visible, path));
-            saved.push({ path, parts: held(undefined, parts, file) });
-        }
-        return committed(locator, target, saved, new Set(), writtenBy);
-    }
-    function carriedDrafts(locator, saved, consumed) {
-        const holding = roomDrafts.get(locator);
-        return new Map(saved.flatMap(({ path, parts }) => {
-            const record = holding?.get(path);
-            if (parts.move === undefined || record === undefined || consumed.has(path))
-                return [];
-            const to = moveTarget(parts.move);
-            if (to === path || holding?.has(to) === true)
-                return [];
-            return [[path, { ...record, path: to, revision: roomDraftRevision() }]];
-        }));
-    }
-    async function committed(locator, { local, replica, room }, saved, consumed, writtenBy) {
-        const changed = saved.flatMap(({ path, parts }) => changedParts(path, underneath(parts, path, replica.visible)));
-        if (changed.length > 0)
-            return { outcome: 'refused', code: 'changed-underneath', retryable: false, parts: changed };
-        const parts = saved.map(({ path, parts }) => changesOf(path, parts));
-        const changes = parts.flatMap(({ changes }) => changes);
-        const requeue = requeued(replica.queue, changes, replica.visible, withdrawable, (queue) => replicaOf(replica.confirmed, queue, replica).visible);
-        if (requeue.kind === 'refused')
-            return { outcome: 'refused', ...requeue.refusal };
-        const foreign = [...requeue.withdrawn.keys()].some((origin) => {
-            const writer = replica.queue.find((batch) => batch.id === origin)?.writtenBy;
-            return writer?.app !== writtenBy?.app || writer?.release !== writtenBy?.release;
-        });
-        if (foreign) {
-            return {
-                outcome: 'refused',
-                code: 'unknown-revision',
-                retryable: false,
-                file: [...requeue.queued].at(-1),
-            };
-        }
-        const withdrawing = requeue.withdrawn.size > 0;
-        const input = {
-            local: localSaves,
-            baseRoomVersion: replica.confirmed.record.roomVersion,
-            composition: compositionFor(replica.confirmed.record),
-            operations: room.operations,
-            providerOwnedPaths: room.providerOwnedPaths,
-            providerLimits: limits,
-            handle: room.handle,
-            visible: replica.visible,
-            changes,
-            bases: parts.flatMap(({ bases }) => bases),
-            queued: queuedDocuments(replica.queue),
-            writtenBy,
-            clean: {
-                text: replica.confirmed.record.documents,
-                binaries: replica.confirmed.record.binaries,
-                composition: compositionOf(replica.confirmed.record),
-            },
-        };
-        const checked = withdrawing
-            ? buildBatch({ ...input, queued: new Set([...input.queued, ...requeue.queued]) })
-            : null;
-        if (checked?.kind === 'refused')
-            return { outcome: 'refused', ...checked.refusal };
-        const owners = [...requeue.owners].flatMap((origin) => {
-            const batch = requeue.withdrawn.get(origin);
-            return batch === undefined || batch === null ? [] : [{ origin, batch }];
-        });
-        if (owners.length > 1) {
-            return {
-                outcome: 'refused',
-                code: 'unknown-revision',
-                retryable: false,
-                file: [...requeue.queued].at(-1),
-            };
-        }
-        const built = !withdrawing
-            ? buildBatch(input)
-            : requeue.changes.length === 0
-                ? null
-                : buildBatch({
-                    ...input,
-                    visible: replicaOf(replica.confirmed, requeue.queue, replica).visible,
-                    changes: requeue.changes,
-                    queued: queuedDocuments(requeue.queue),
-                });
-        if (built?.kind === 'refused')
-            return { outcome: 'refused', ...built.refusal };
-        const [owner] = owners;
-        const join = built === null || owner === undefined
-            ? null
-            : joined(requeue.queue, owner.batch, built.batch);
-        if (join?.kind === 'refused')
-            return { outcome: 'refused', ...join.refusal };
-        const withdrawn = new Map(requeue.withdrawn);
-        if (join !== null && owner !== undefined)
-            withdrawn.set(owner.origin, join.batch);
-        const drafted = new Map();
-        for (const [origin, replaced] of withdrawn) {
-            if (replaced === null)
-                continue;
-            const carried = withdrawnDrafts(pendings.get(origin)?.drafts ?? [], changes);
-            drafted.set(replaced.id, replaced === join?.batch
-                ? [
-                    ...carried.map((held) => joinedDraft(held, saved)),
-                    ...saved.filter((draft) => !carried.some((held) => held.path === draft.path)),
-                ]
-                : carried);
-        }
-        if (built !== null && join === null)
-            drafted.set(built.batch.id, saved);
-        const batches = join !== null ? join.queue : built === null ? requeue.queue : [...requeue.queue, built.batch];
-        for (const replaced of withdrawn.values()) {
-            if (replaced === null || !batches.includes(replaced))
-                continue;
-            const limited = limitedIn(batches, replaced, limits, (queue) => replicaOf(replica.confirmed, queue, replica).visible);
-            if (limited !== null)
-                return { outcome: 'refused', ...limited };
-        }
-        const carried = carriedDrafts(locator, saved, consumed);
-        const left = [...consumed, ...carried.keys()];
-        const arrived = [...carried.values()];
-        try {
-            await local.keepAuthored({
-                locator,
-                queue: batches,
-                saved: drafted,
-                consumedRoomDrafts: left,
-                roomDrafts: arrived,
-            });
-        }
-        catch {
-            return { outcome: 'refused', code: 'durable-write', retryable: true };
-        }
-        if (fences.has(locator))
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
-        for (const origin of withdrawn.keys())
-            pendings.delete(origin);
-        for (const [id, drafts] of drafted) {
-            pendings.set(id, { drafts, submission: { state: 'waiting' }, lost: false });
-        }
-        if (!localSaves)
-            recorded = false;
-        for (const path of left)
-            forgetRoomDraft(locator, path);
-        for (const record of arrived)
-            rememberRoomDraft(record);
-        replicas.set(locator, replicaOf(replica.confirmed, batches, replica));
-        publishChangeSet(changeSet(locator, replica, replicas.get(locator) ?? null, {
-            queue: true,
-            drafts: [...left, ...arrived.map(({ path }) => path)],
-        }));
-        moveTo({ ...(localSaves ? status : saving(status)), ...attention() });
-        submitLater(locator);
-        const identifier = join?.batch.id ??
-            built?.batch.id ??
-            [...requeue.withdrawn].map(([origin, replaced]) => replaced?.id ?? origin).at(-1);
-        return { outcome: 'saved', identifier };
-    }
-    async function mark(local, locator, identifier, submission, lost) {
-        const state = pendings.get(identifier);
-        if (!continuing() ||
-            state === undefined ||
-            (JSON.stringify(state.submission) === JSON.stringify(submission) && state.lost === lost)) {
-            return;
-        }
-        await local.submit(locator, identifier, submission, lost);
-        if (fences.has(locator))
-            return;
-        pendings.set(identifier, { ...state, submission, lost });
-        const replica = replicas.get(locator);
-        if (replica !== undefined)
-            publishChangeSet(changeSet(locator, replica, replica, { queue: true }));
-        moveTo({ ...status, ...attention() });
-    }
-    async function keepUpload(local, locator, identifier, upload) {
-        if (!continuing())
-            throw new Error('connection refused');
-        await local.keepUpload(locator, identifier, upload);
-        if (fences.has(locator))
-            throw runtimeError('room-not-held', `No Local Replica for ${locator}`);
-        pendings.set(identifier, { ...pendings.get(identifier), upload });
-        if (!continuing())
-            throw new Error('connection refused');
-    }
-    async function readHistory(locator, path, query = {}) {
-        if (closed || refusal !== null)
-            return UNCERTAIN;
-        try {
-            await ensureAuthorization();
-        }
-        catch {
-            return UNCERTAIN;
-        }
-        if (closed || authorization === undefined || refusal !== null)
-            return UNCERTAIN;
-        const since = fencings;
-        const transfer = ['transfer', 'history', locator, path];
-        if (query.revision !== undefined)
-            transfer.push(query.revision);
-        if (query.pageToken !== undefined)
-            transfer.push(query.pageToken);
-        journal.record(transfer.join(' '));
-        try {
-            const result = await options.adapter.history(authorization, {
-                locator,
-                path,
-                ...(query.revision === undefined ? {} : { revision: query.revision }),
-                ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
-            });
-            journal.record(`outcome history ${result.kind}`);
-            if (fencedSince(locator, since))
-                return failure({ kind: 'room-not-readable', locator });
-            if (result.kind === 'scoped-refusal') {
-                const room = replicas.get(result.locator)?.confirmed.record;
-                if (room !== undefined)
-                    await scoped(result, room, await openLocal());
-            }
-            if (result.kind === 'revoked-authorization')
-                await refuse('revoked-authorization');
-            return historyAnswer(result);
-        }
-        catch {
-            journal.record('outcome history transport-uncertainty');
-            return UNCERTAIN;
-        }
-    }
-    function queuedBlob(locator, path, localId) {
-        for (const batch of replicas.get(locator)?.queue ?? []) {
-            const change = batch.changes[queuedFile(batch, path, localId)];
-            if (change?.kind === 'binary')
-                return change.blob;
-        }
-        return null;
-    }
-    function binaryRoom(request) {
-        if (request.kind === 'path')
-            return request.locator;
-        const scope = options.adapter.referrerScope(request.referrer);
-        return scope?.kind === 'room' ? scope.locator : null;
-    }
-    async function transferBinary(request, transfer, answer) {
-        if (closed || refusal !== null)
-            return UNCERTAIN;
-        try {
-            await ensureAuthorization();
-        }
-        catch {
-            return UNCERTAIN;
-        }
-        if (closed || authorization === undefined || refusal !== null)
-            return UNCERTAIN;
-        const since = fencings;
-        journal.record(request.kind === 'path'
-            ? `transfer binary ${request.locator} ${request.path}`
-            : `transfer binary ${request.fileRef}`);
-        try {
-            const result = await transfer(authorization);
-            const settled = result;
-            journal.record(`outcome binary ${settled.kind}`);
-            const locator = binaryRoom(request);
-            if (locator !== null && fencedSince(locator, since))
-                return failure({ kind: 'room-not-readable', locator });
-            if (settled.kind === 'scoped-refusal') {
-                const room = replicas.get(settled.locator)?.confirmed.record;
-                if (room !== undefined)
-                    await scoped(settled, room, await openLocal());
-            }
-            if (settled.kind === 'revoked-authorization')
-                await refuse('revoked-authorization');
-            return answer(result);
-        }
-        catch {
-            journal.record('outcome binary transport-uncertainty');
-            return UNCERTAIN;
-        }
-    }
-    function readBinary(request) {
-        return transferBinary(request, (held) => options.adapter.binary(held, request), binaryAnswer);
-    }
-    function binaryPath(locator, path, revision) {
-        if (revision !== undefined)
-            return { kind: 'path', locator, path, revision };
-        const visible = replicas.get(locator)?.visible;
-        const held = visible?.binaries[path];
-        if (visible === undefined || held === undefined)
-            return null;
-        if (held.state === 'pending')
-            return { kind: 'pending', localId: held.localId };
-        const record = binaryRecord(path, held, visible.revisions[path]);
-        if (record.state !== 'accepted')
-            return null;
-        const replica = replicas.get(locator);
-        const queued = (replica?.queue ?? []).flatMap((batch) => batch.changes);
-        const holds = (at) => {
-            const kept = replica?.confirmed.record.binaries[at];
-            return (kept?.state === 'accepted' &&
-                kept.fileRef === record.fileRef &&
-                replica?.confirmed.record.revisions[at] === record.revision);
-        };
-        let confirmed = path;
-        for (let index = queued.length - 1; index >= 0 && !holds(confirmed); index -= 1) {
-            const change = queued[index];
-            if (change.kind === 'move' && change.to === confirmed)
-                confirmed = change.path;
-        }
-        return {
-            kind: 'path',
-            locator,
-            path: confirmed,
-            revision: record.revision,
-            fileRef: record.fileRef,
-        };
-    }
-    async function readBinaryPath(locator, path, revision) {
-        await ready;
-        const asked = binaryPath(locator, path, revision);
-        if (asked === null)
-            return absentBinary(path);
-        if (asked.kind === 'pending') {
-            const blob = queuedBlob(locator, path, asked.localId);
-            return blob === null ? absentBinary(path) : { kind: 'binary', blob };
-        }
-        return readBinary(asked);
-    }
-    async function linkBinaryPath(locator, path, revision) {
-        await ready;
-        const asked = binaryPath(locator, path, revision);
-        if (asked === null || asked.kind === 'pending')
-            return absentBinary(path);
-        return transferBinary(asked, (held) => options.adapter.link(held, asked), binaryLinkAnswer);
-    }
-    async function readBinaryReference(reference) {
-        await ready;
-        return readBinary({
-            kind: 'reference',
-            fileRef: reference.fileRef,
-            referrer: reference.referrer,
-        });
-    }
-    function declaredAgents() {
-        for (const capability of capabilities) {
-            if (capability.conversationAgents !== undefined)
-                return capability.conversationAgents;
-        }
-        return undefined;
-    }
-    function declaredAction(name) {
-        for (const capability of capabilities) {
-            for (const action of capability.actions ?? []) {
-                if (action.name === name)
-                    return action;
-            }
-        }
-        return undefined;
-    }
-    async function invokeAction(name, input, dispatching) {
-        await ready;
-        if (closed || refusal !== null)
-            return UNCERTAIN;
-        if (declaredAction(name) === undefined)
-            return undeclared(name);
-        try {
-            await ensureAuthorization();
-        }
-        catch {
-            return UNCERTAIN;
-        }
-        if (closed || authorization === undefined || refusal !== null)
-            return UNCERTAIN;
-        await dispatching?.();
-        journal.record(`transfer action ${name}`);
-        try {
-            const result = await options.adapter.action(authorization, { name, input });
-            if (result.kind === 'scoped-refusal') {
-                const room = replicas.get(result.locator)?.confirmed.record;
-                if (room !== undefined)
-                    await scoped(result, room, await openLocal());
-            }
-            if (result.kind === 'revoked-authorization')
-                await refuse('revoked-authorization');
-            journal.record(`outcome action ${result.kind}`);
-            if (result.kind === 'rejected')
-                journal.record(`refusal rejected ${result.code}`);
-            return calledResult(result);
-        }
-        catch {
-            journal.record('outcome action transport-uncertainty');
-            return UNCERTAIN;
-        }
-    }
-    function unsettled(result) {
-        return result.kind !== 'action' && result.retryable;
-    }
-    async function recoveredAction(name, input) {
-        const operation = operationOf(input);
-        if (operation === null)
-            return invokeAction(name, input);
-        const kept = async () => (await openLocal()).keepCall({ operation, name, input });
-        calling.add(operation);
-        try {
-            let result = await invokeAction(name, input, kept);
-            if (unsettled(result)) {
-                await recovery.attempt(`action ${operation}`, async () => {
-                    if (closed || refusal !== null)
-                        return 'done';
-                    if (!socketOpen)
-                        return 'again';
-                    result = await invokeAction(name, input, kept);
-                    return unsettled(result) ? 'again' : 'done';
-                }, { again: true });
-            }
-            if (!unsettled(result))
-                await (await openLocal()).dropCall(operation);
-            return result;
-        }
-        finally {
-            calling.delete(operation);
-        }
-    }
-    async function resendCalls(signal) {
-        if (!socketOpen || closed || stopping)
-            return 'done';
-        const local = await openLocal();
-        for (const held of await local.calls()) {
-            if (calling.has(held.operation))
-                continue;
-            if (closed || signal.aborted)
-                return 'done';
-            if (pastHorizon(held.operation)) {
-                await local.dropCall(held.operation);
-                continue;
-            }
-            calling.add(held.operation);
-            try {
-                if (unsettled(await invokeAction(held.name, held.input)))
-                    return 'again';
-                await local.dropCall(held.operation);
-            }
-            finally {
-                calling.delete(held.operation);
-            }
-        }
-        return 'done';
-    }
-    function continuing() {
-        return !closed && !discoveryPaused;
-    }
-    function reachedBy(locator, roomVersion) {
-        const held = replicas.get(locator);
-        return (held !== undefined &&
-            options.adapter.reached(locator, held.confirmed.record.roomVersion, roomVersion));
-    }
-    function writtenAfter(locator, roomVersion, path) {
-        const written = replicas.get(locator)?.confirmed.record.written[path];
-        return (written !== undefined &&
-            options.adapter.reached(locator, written, roomVersion) &&
-            !options.adapter.reached(locator, roomVersion, written));
-    }
-    async function pullRefresh(authorized, confirmed, live) {
-        if (!live())
-            return unconfirmed;
-        const turn = generation;
-        try {
-            const result = await refreshRoom(reads, authorized, confirmed, (models, held) => (live() ? remodel(confirmed.record.locator, models, held) : held), live);
-            const detail = result.kind === 'advanced' ? result.confirmed.record.roomVersion : result.kind;
-            journal.record(`transfer refresh ${confirmed.record.locator} ${detail}`);
-            return result;
-        }
-        catch (error) {
-            journal.record(`transfer refresh ${confirmed.record.locator} transport-uncertainty`);
-            throw error;
-        }
-        finally {
-            reads.finished(confirmed.record.locator, turn);
-        }
-    }
-    function staging(local, live) {
-        return {
-            held: (locator) => transfers.get(locator) ?? null,
-            staged: (record) => local.staged(record),
-            stage: (record, page) => exclusive(async () => {
-                if (!live())
-                    return false;
-                const bytes = layerBytes(page);
-                if (!(await admitted(local, record.locator, bytes)))
-                    return false;
+    const socket = createSocket(adapter, journal, options.authorization);
+    const store = createStore({
+        database: {
+            async ask(request) {
                 try {
-                    await local.stage(record, page);
+                    return await options.database.ask(request);
                 }
                 catch (error) {
-                    if (!exceeded(error))
-                        throw error;
-                    await exceededOn(record.locator, bytes);
-                    return false;
-                }
-                transfers.set(record.locator, record);
-                readSide.recover();
-                return true;
-            }),
-            abandon: (locator) => exclusive(async () => {
-                if (!live())
-                    return;
-                await local.abandon(locator);
-                transfers.delete(locator);
-                readSide.recover();
-            }),
-        };
-    }
-    function reusable(room) {
-        const record = replicas.get(room.locator)?.confirmed.record;
-        if (record === undefined || record.replica.selection !== room.replica.selection)
-            return null;
-        return { documents: record.documents, revisions: record.revisions };
-    }
-    async function pullBootstrap(authorized, room, local, live) {
-        if (!live())
-            return unconfirmed;
-        const turn = generation;
-        if (replicas.has(room.locator)) {
-            catching.add(room.locator);
-            readSide.recover();
-        }
-        try {
-            const result = await bootstrapRoom(reads, authorized, room, {
-                collection: modelOf(room.locator),
-                selection: modelOf(room.locator, 'typed-selection'),
-            }, (models, held) => (live() ? remodel(room.locator, models, held) : held), live, staging(local, live), reusable(room));
-            const detail = result.kind === 'staged' ? result.confirmed.record.roomVersion : result.kind;
-            journal.record(`transfer bootstrap ${room.locator} ${detail}`);
-            if (result.kind !== 'staged')
-                caughtUpTo(room.locator);
-            return result;
-        }
-        catch (error) {
-            journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
-            caughtUpTo(room.locator);
-            throw error;
-        }
-        finally {
-            reads.finished(room.locator, turn);
-        }
-    }
-    function caughtUpTo(locator) {
-        if (catching.delete(locator))
-            readSide.recover();
-    }
-    function behind(room) {
-        const held = replicas.get(room.locator)?.confirmed.record.roomVersion;
-        return (held !== undefined &&
-            [announced.get(room.locator), room.roomVersion].some((later) => later !== undefined && !options.adapter.reached(room.locator, held, later)));
-    }
-    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);
-    }
-    async function advanceOnce(room, local, authorized, live) {
-        await referenced(room.locator);
-        if (!live() || paused.has(room.locator))
-            return unconfirmed;
-        const held = replicas.get(room.locator);
-        if (held !== undefined) {
-            const refreshed = await pullRefresh(authorized, held.confirmed, live);
-            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') {
-                if (!(await publish(local, room, refreshed.confirmed, { base: held.confirmed }, live))) {
-                    const now = replicas.get(room.locator)?.confirmed.record.roomVersion;
-                    const reached = now !== undefined &&
-                        options.adapter.reached(room.locator, now, refreshed.confirmed.record.roomVersion);
-                    return reached ? null : advance(room, local, authorized, live);
-                }
-                await retainModel(local, room, 'collection', modelOf(room.locator));
-                return null;
-            }
-            if (refreshed.kind !== 'beyond-horizon')
-                return refreshed;
-            if (opened !== null) {
-                owed.add(room.locator);
-                readSide.recover();
-                return unconfirmed;
-            }
-        }
-        const bootstrapped = await pullBootstrap(authorized, room, local, live);
-        if (!live())
-            return unconfirmed;
-        if (bootstrapped.kind !== 'staged')
-            return bootstrapped;
-        await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored }, live);
-        return null;
-    }
-    async function withhold(withheld, room, local, progress) {
-        if (withheld.kind === 'unconfirmed')
-            return;
-        if (withheld.kind === 'refused')
-            stale.delete(room.locator);
-        else
-            stale.add(room.locator);
-        if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
-            const reset = withheld.kind === 'retryable-refusal' ? withheld.reset : undefined;
-            repairable.set(room.locator, reset);
-            repairLater(room.locator, reset === undefined ? { again: true } : { at: Date.parse(reset) });
-        }
-        else
-            repairable.delete(room.locator);
-        if (withheld.kind === 'scoped-refusal') {
-            await scoped(withheld, room, local);
-        }
-        else if (withheld.kind === 'transport-uncertainty') {
-            progress.reachable = false;
-        }
-        else if (withheld.kind === 'retryable-refusal') {
-            journal.record(`refusal ${withheld.kind} ${withheld.code}`);
-        }
-        else if (withheld.kind === 'room-not-readable') {
-            unreadable.add(room.locator);
-            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') };
-        return {
-            batch,
-            returned: {
-                kind: result.kind,
-                code: result.code,
-                fields: result.fields,
-                retryable: result.retryable,
-            },
-        };
-    }
-    function logAccepted(locator, submitted, accepted) {
-        journal.record(`outcome ${locator} ${submitted.id} accepted ${accepted.roomVersion}` +
-            (accepted.author === undefined ? '' : ` author ${accepted.author}`) +
-            (accepted.time === undefined ? '' : ` time ${accepted.time}`));
-    }
-    async function adoptAccepted(room, local, submitted, accepted) {
-        await referenced(room.locator);
-        if (!continuing())
-            return unconfirmed;
-        const current = replicas.get(room.locator);
-        if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
-            return null;
-        }
-        const held = current.confirmed.record.roomVersion;
-        logAccepted(room.locator, submitted, accepted);
-        const applied = options.adapter.reached(room.locator, held, accepted.roomVersion)
-            ? { kind: 'staged', confirmed: current.confirmed }
-            : applyReturned(current.confirmed, submitted, accepted, options.adapter.follows(room.locator, held, accepted.roomVersion)
-                ? accepted.roomVersion
-                : held, accepted.roomVersion);
-        if (applied.kind !== 'staged') {
-            const state = pendings.get(submitted.id);
-            await local.accept(room.locator, submitted.id, accepted.roomVersion);
-            if (state !== undefined && !fences.has(room.locator))
-                pendings.set(submitted.id, { ...state, accepted: accepted.roomVersion });
-            emitQueue(room.locator);
-            return applied;
-        }
-        const settled = await settle(local, room.locator, current, applied.confirmed, current.queue.filter((batch) => batch.id !== submitted.id), { room: true });
-        pendings.delete(submitted.id);
-        unreadable.delete(room.locator);
-        sourceRefusals.delete(room.locator);
-        declarationRefusals.delete(room.locator);
-        const set = settled();
-        list(room, true);
-        publishChangeSet(set);
-        moveTo({ ...status, ...attention() });
-        return null;
-    }
-    async function adopted(room, local, submitted, accepted) {
-        const failed = await exclusive(() => adoptAccepted(room, local, submitted, accepted));
-        if (failed === null)
-            return true;
-        if (failed.kind === 'refused' && continuing())
-            refusedSource(room, failed);
-        return false;
-    }
-    async function submitRoom(room, local, authorized, progress, signal) {
-        while (continuing() && authorization !== undefined && !signal.aborted) {
-            const replica = replicas.get(room.locator);
-            const head = replica?.queue[0];
-            if (replica === undefined || head === undefined)
-                return 'done';
-            if (pendings.get(head.id)?.accepted !== undefined)
-                return 'done';
-            const state = pendings.get(head.id);
-            const { submission, lost: earlier } = state ?? {
-                submission: { state: 'waiting' },
-                lost: false,
-            };
-            if (submission.state === 'reset' && Date.now() < Date.parse(submission.reset)) {
-                progress.complete = false;
-                return { at: Date.parse(submission.reset) };
-            }
-            if (writesHeld()) {
-                progress.complete = false;
-                journal.record(`submission ${room.locator} ${head.id} held`);
-                return 'done';
-            }
-            const lost = earlier || submission.state === 'submitted';
-            if (lost && pastHorizon(head.id)) {
-                await discardPending(room, local, signal);
-                return 'done';
-            }
-            let result;
-            journal.record(`submission ${room.locator} ${head.id}`);
-            await exclusive(() => mark(local, room.locator, head.id, { state: 'submitted' }, lost));
-            if (discoveryPaused || fences.has(room.locator))
-                return 'done';
-            if (signal.aborted || writesHeld()) {
-                await exclusive(() => mark(local, room.locator, head.id, submission, earlier));
-                if (signal.aborted)
-                    return 'done';
-                progress.complete = false;
-                journal.record(`submission ${room.locator} ${head.id} held`);
-                return 'done';
-            }
-            const opensBefore = openSignals;
-            const answered = awaitingAnswer(room.locator);
-            try {
-                result = await options.adapter.mutate(authorized, {
-                    locator: room.locator,
-                    changeBatch: head,
-                    ...(state?.upload === undefined ? {} : { upload: state.upload }),
-                }, (upload) => exclusive(() => keepUpload(local, room.locator, head.id, upload)));
-            }
-            catch {
-                answered();
-                progress.complete = false;
-                if (continuing())
-                    progress.reachable = false;
-                return 'again';
-            }
-            if (signal.aborted) {
-                answered();
-                return 'done';
-            }
-            if (result.kind !== 'accepted' || !continuing())
-                answered();
-            if (!continuing())
-                return 'done';
-            if (result.kind === 'transport-uncertainty') {
-                progress.complete = false;
-                progress.reachable = false;
-                return 'again';
-            }
-            if (result.kind === 'room-not-readable') {
-                progress.complete = false;
-                unreadable.add(room.locator);
-                list(room, false);
-                emitRooms();
-                return 'done';
-            }
-            if (result.kind === 'revoked-authorization') {
-                await refuse('revoked-authorization');
-                return 'done';
-            }
-            if (result.kind === 'scoped-refusal') {
-                await scoped(result, room, local);
-                progress.complete = false;
-                return 'done';
-            }
-            if (result.kind === 'write-halted') {
-                journal.record(`outcome ${room.locator} ${head.id} write-halted`);
-                await exclusive(() => mark(local, room.locator, head.id, { state: 'waiting' }, lost));
-                if (serviceMode === 'open' && openSignals !== opensBefore)
-                    continue;
-                haltedRefusal = true;
-                progress.complete = false;
-                return 'done';
-            }
-            if (result.kind === 'conflicted' ||
-                result.kind === 'rejected' ||
-                result.kind === 'expired' ||
-                result.kind === 'retryable-refusal') {
-                if (result.kind === 'expired' && lost && result.restored !== true) {
-                    journal.record(`outcome ${room.locator} ${head.id} expired`);
-                    await discardPending(room, local, signal);
-                    return 'done';
-                }
-                if (result.kind === 'expired') {
-                    await exclusive(() => mark(local, room.locator, head.id, { state: 'waiting' }, false));
-                    const withheld = await advance(room, local, authorized, continuing);
-                    if (withheld !== null) {
-                        await withhold(withheld, room, local, progress);
-                        return 'done';
-                    }
-                }
-                journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` +
-                    (result.kind === 'conflicted' && result.roomVersion !== undefined
-                        ? ` ${result.roomVersion}`
-                        : ''));
-                if (result.kind !== 'expired')
-                    journal.record(`refusal ${result.kind} ${result.code}`);
-            }
-            if (result.kind === 'retryable-refusal') {
-                const reset = result.reset;
-                progress.complete = false;
-                await exclusive(() => mark(local, room.locator, head.id, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
-                return reset === undefined ? 'again' : { at: Date.parse(reset) };
-            }
-            if (result.kind === 'conflicted' || result.kind === 'rejected' || result.kind === 'expired') {
-                const left = leaving(head, result);
-                await exclusive(async () => {
-                    if (!continuing())
-                        return;
-                    const current = replicas.get(room.locator);
-                    if (current === undefined || !current.queue.some((batch) => batch.id === head.id)) {
-                        return;
-                    }
-                    const settled = await settle(local, room.locator, current, current.confirmed, current.queue.filter((batch) => batch.id !== head.id), {
-                        leaving: (result.kind === 'expired' && landed(head, current.confirmed)) ||
-                            (result.kind === 'conflicted' && landed(head, current.confirmed, result.affected))
-                            ? { ...left, returned: null }
-                            : left,
-                    });
-                    publishChangeSet(settled());
-                    moveTo({ ...status, ...attention() });
-                });
-                if (result.kind === 'expired')
-                    continue;
-                const withheld = await advance(room, local, authorized, continuing);
-                if (withheld !== null) {
-                    await withhold(withheld, room, local, progress);
-                    return 'done';
-                }
-                continue;
-            }
-            const kept = await adopted(room, local, head, result).finally(answered);
-            if (!kept) {
-                progress.complete = false;
-                return 'done';
-            }
-        }
-        return 'done';
-    }
-    function pastHorizon(identity) {
-        return (outcomeRetention !== null && identityTime(identity) + outcomeRetention * 1000 <= Date.now());
-    }
-    async function discardPending(room, local, signal) {
-        const { locator } = room;
-        const discarded = await exclusive(async () => {
-            if (fences.has(locator))
-                return false;
-            const before = replicas.get(locator);
-            const queue = before?.queue ?? queuesWithoutReplica.get(locator) ?? [];
-            fences.set(locator, { at: discoveries, erased: false });
-            lastFenced.set(locator, ++fencings);
-            try {
-                await local.discard(locator);
-            }
-            finally {
-                fences.delete(locator);
-            }
-            for (const batch of queue)
-                pendings.delete(batch.id);
-            queuesWithoutReplica.delete(locator);
-            const after = before === undefined ? null : replicaOf(before.confirmed, [], before);
-            if (after !== null)
-                replicas.set(locator, after);
-            journal.record(`room discarded ${locator}`);
-            publishChangeSet(changeSet(locator, before ?? null, after, { queue: true }));
-            moveTo({ ...status, ...attention() });
-            return true;
-        });
-        if (!discarded)
-            return;
-        const progress = { complete: true, reachable: true };
-        await roomTask(locator, async (live) => {
-            await Promise.race([
-                reload(room, local, progress, () => live() && !signal.aborted),
-                abandonedOn(signal),
-            ]);
-        });
-        if (signal.aborted)
-            return;
-        await rest(progress);
-    }
-    function awaitingAnswer(locator) {
-        let release = () => { };
-        const awaited = new Promise((resolve) => {
-            release = resolve;
-        });
-        answering.set(locator, { generation, answered: awaited });
-        return () => {
-            if (answering.get(locator)?.answered === awaited)
-                answering.delete(locator);
-            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)?.confirmed.record;
-        if (JSON.stringify(previous) === JSON.stringify(next) &&
-            (heldBefore === undefined ||
-                (JSON.stringify(heldBefore.operations) === JSON.stringify(room.operations) &&
-                    JSON.stringify(heldBefore.replica) === JSON.stringify(room.replica) &&
-                    JSON.stringify(heldBefore.typedSelection) ===
-                        JSON.stringify(room.typedSelection ?? null))))
-            return;
-        if (next.status === 'unavailable') {
-            invalidModels.add(key);
-            liveModels.delete(key);
-        }
-        await exclusive(async () => {
-            if (!continuing())
-                return;
-            const held = replicas.get(room.locator);
-            if (held !== undefined) {
-                const declared = {
-                    ...held.confirmed.record,
-                    operations: room.operations,
-                    replica: room.replica,
-                    typedSelection: room.typedSelection ?? null,
-                    ...(attached === 'collection' ? { model: next } : { selectionModel: next }),
-                };
-                const reclassified = sameMembership(declared, held.confirmed.record)
-                    ? { kind: 'staged', confirmed: confirmedOf(declared, held.confirmed) }
-                    : readReclassified(declared, held.confirmed);
-                const record = reclassified.kind === 'staged'
-                    ? declared
-                    : {
-                        ...declared,
-                        typedSelection: held.confirmed.record.typedSelection,
-                    };
-                const read = reclassified.kind === 'deferred'
-                    ? { kind: 'staged', confirmed: confirmedOf(record, held.confirmed) }
-                    : reclassified;
-                await local.write({ next: record, previous: held.confirmed.record });
-                if (read.kind === 'staged') {
-                    replicas.set(room.locator, replicaOf(read.confirmed, held.queue, held));
-                    if (declarationRefusals.delete(room.locator)) {
-                        sourceRefusals.delete(room.locator);
-                        unreadable.delete(room.locator);
-                    }
-                }
-                else if (read.kind === 'refused') {
-                    replicas.set(room.locator, { ...held, confirmed: { ...held.confirmed, record } });
-                    refusedSource(room, read);
-                    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));
-            if (held === undefined)
-                emitRooms();
-            else
-                publishChangeSet(changeSet(room.locator, held, replicas.get(room.locator) ?? null, { room: true }));
-        });
-    }
-    async function scoped(result, room, local) {
-        if ((result.scope === 'content' || result.scope === 'sync') && !result.retryable) {
-            journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
-            await loseRooms([room.locator]);
-            return;
-        }
-        scopedRefusals.set(room.locator, {
-            code: result.code,
-            fields: result.fields,
-            retryable: result.retryable,
-        });
-        let scopedAway = room;
-        if (result.scope === 'model')
-            await retainModel(local, room, 'collection', {
-                status: 'unavailable',
-                reason: 'not-readable',
-            });
-        else if (result.scope !== 'operation') {
-            unreadable.add(room.locator);
-            scopedAway = {
-                ...room,
-                replica: { ...room.replica, admission: 'unavailable' },
-                operations: {
-                    ...room.operations,
-                    ...(result.scope === 'content' ? { read: [] } : {}),
-                    ...(result.scope === 'sync' ? { sync: [] } : {}),
-                },
-            };
-            await retainModel(local, scopedAway, 'collection', modelOf(room.locator));
-        }
-        if (!continuing())
-            return;
-        list(scopedAway, scopedAway.replica.admission === 'admitted' && !unreadable.has(room.locator));
-        emitRooms();
-        journal.record(`scoped refusal ${room.locator} ${result.scope} ${result.code}`);
-    }
-    function heldRooms(listed) {
-        return listed.flatMap((room) => {
-            const record = replicas.get(room.locator)?.confirmed.record;
-            if (record === undefined || record.replica.selection !== room.replica.selection)
-                return [];
-            return [
-                {
-                    locator: room.locator,
-                    roomVersion: record.roomVersion,
-                    documents: record.documents,
-                    revisions: record.revisions,
-                },
-            ];
-        });
-    }
-    async function synchronize(listed, local, progress, attempt, live) {
-        const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(room, local, progress)));
-        if (!live())
-            return;
-        const ready = listed.filter((_, index) => {
-            const outcome = prepared[index];
-            return outcome?.status === 'fulfilled' && outcome.value;
-        });
-        if (attempt === 'opened') {
-            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');
-        if (failed !== undefined)
-            throw failed.reason;
-    }
-    async function prepareRoom(room, local, progress) {
-        if (closed || authorization === undefined) {
-            progress.complete = false;
-            return false;
-        }
-        const prior = replicas.get(room.locator)?.confirmed.record;
-        if (prior !== undefined && prior.replica.selection !== room.replica.selection) {
-            list(prior, false);
-            emitRooms();
-            journal.record(`selection changed ${room.locator}`);
-            progress.complete = false;
-            return false;
-        }
-        if (prior !== undefined)
-            await retainModel(local, room, 'collection', modelOf(room.locator));
-        if (discoveryPaused || authorization === undefined)
-            return false;
-        return room.replica.admission === 'admitted';
-    }
-    async function caughtUp(room, local, progress, live) {
-        if (authorization === undefined || !live() || !behind(room))
-            return;
-        const withheld = await advance(room, local, authorization, live);
-        if (withheld !== null)
-            await withhold(withheld, room, local, progress);
-    }
-    function revoked(locator) {
-        return ['collection', 'typed-selection'].some((attached) => {
-            const model = modelOf(locator, attached);
-            return model.status === 'unavailable' && model.reason === 'revoked';
-        });
-    }
-    async function loadRoom(room, local, progress, live) {
-        if (!live() || authorization === undefined)
-            return;
-        if (replicas.has(room.locator) && revoked(room.locator)) {
-            await reload(room, local, progress, live);
-            return;
-        }
-        const withheld = await advance(room, local, authorization, live);
-        if (withheld !== null) {
-            await withhold(withheld, room, local, progress);
-            return;
-        }
-        await caughtUp(room, local, progress, live);
-    }
-    async function reload(room, local, progress, live) {
-        try {
-            if (!live() || authorization === undefined)
-                return;
-            const bootstrapped = await pullBootstrap(authorization, room, local, live);
-            if (!live())
-                return;
-            if (bootstrapped.kind !== 'staged') {
-                await withhold(bootstrapped, room, local, progress);
-                return;
-            }
-            await publish(local, room, bootstrapped.confirmed, { stored: bootstrapped.stored }, live);
-            await caughtUp(room, local, progress, live);
-        }
-        finally {
-            caughtUpTo(room.locator);
-        }
-    }
-    async function discoverRooms(local, progress, attempt, live, scope) {
-        if (closed || authorization === undefined) {
-            notifyReady();
-            return;
-        }
-        moveTo(transferring(status));
-        discoveries += 1;
-        const started = discoveries;
-        let result;
-        try {
-            result = await options.adapter.discover(authorization, scope);
-        }
-        catch {
-            result = { kind: 'transport-uncertainty' };
-        }
-        if (!live()) {
-            progress.complete = false;
-            notifyReady();
-            return;
-        }
-        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')));
-                }
-            }
-            progress.reachable = false;
-            progress.complete = false;
-            notifyReady();
-            return;
-        }
-        if (result.kind === 'contract-unavailable') {
-            journal.record(`connection contract unavailable ${result.code}`);
-            await refuse('missing-required-guarantee', {
-                code: result.code,
-                fields: result.fields,
-                retryable: result.retryable,
-            });
-            notifyReady();
-            return;
-        }
-        if (result.kind === 'revoked-authorization') {
-            await refuse('revoked-authorization');
-            notifyReady();
-            return;
-        }
-        for (const room of result.rooms) {
-            if (room.operations === undefined ||
-                !['read', 'sync', 'write', 'delete'].every((operation) => Array.isArray(room.operations[operation]) &&
-                    room.operations[operation].every((scope) => typeof scope === 'string')) ||
-                room.replica === undefined ||
-                typeof room.replica.selection !== 'string' ||
-                room.replica.selection.length === 0 ||
-                !['admitted', 'unavailable'].includes(room.replica.admission)) {
-                journal.record(`invalid model or replica declaration ${room.locator}`);
-                await refuse('missing-required-guarantee');
-                notifyReady();
-                return;
-            }
-            if (!declaredSelection(room)) {
-                journal.record(`invalid typed selection declaration ${room.locator}`);
-                await refuse('missing-required-guarantee');
-                notifyReady();
-                return;
-            }
-        }
-        if (refusal !== null) {
-            refusal = null;
-            emitRefusal();
-        }
-        const previousCapabilities = capabilities;
-        capabilities = result.capabilities;
-        outcomeRetention = result.retention.outcome;
-        notifyReady();
-        if (JSON.stringify(result.providerLimits) !== JSON.stringify(limits) ||
-            JSON.stringify(result.capabilities) !== JSON.stringify(previousCapabilities)) {
-            limits = result.providerLimits;
-            await local.declare(limits, capabilities);
-        }
-        const signedIn = result.member ?? null;
-        if (JSON.stringify(signedIn) !== JSON.stringify(member)) {
-            await local.keepMember(signedIn);
-            member = signedIn;
-            emitMember();
-        }
-        await synchronize(await applyDiscovery(result.rooms, started, result.covered), local, progress, attempt, live);
-    }
-    async function ensureAuthorization() {
-        if (authorization !== undefined)
-            return;
-        try {
-            authorization = await options.adapter.authorize();
-            journal.record('connection authorize');
-        }
-        catch (error) {
-            journal.record('connection authorize transport-uncertainty');
-            throw error;
-        }
-    }
-    async function admittedRead(work) {
-        if (roomReads.generation !== generation) {
-            roomReads = { generation, free: ROOM_READS, waiting: [] };
-        }
-        const reads = roomReads;
-        while (reads.free === 0)
-            await new Promise((admit) => reads.waiting.push(admit));
-        reads.free -= 1;
-        try {
-            await work();
-        }
-        finally {
-            reads.free += 1;
-            reads.waiting.shift()?.();
-        }
-    }
-    function roomTask(locator, work) {
-        return task(roomLane(locator), (live) => admittedRead(() => work(live)));
-    }
-    function task(lane, work) {
-        if (stopping)
-            return Promise.resolve();
-        const held = lanes.get(lane);
-        const current = held?.generation === generation ? held : { generation, chain: Promise.resolve() };
-        const turn = current.generation;
-        const live = () => turn === generation && continuing();
-        const run = current.chain.then(() => work(live)).catch(() => undefined);
-        current.chain = run;
-        lanes.set(lane, current);
-        working.add(run);
-        void run.finally(() => working.delete(run));
-        return run;
-    }
-    function sync(attempt) {
-        return task(OPENING_LANE, async (live) => {
-            if (!live()) {
-                notifyReady();
-                return;
-            }
-            const progress = { complete: true, reachable: true };
-            const gate = discover();
-            if (attempt === 'opened')
-                opened = generation;
-            underway = attempt === 'opened' ? { generation, progress } : null;
-            if (attempt === 'opened')
-                streamed = progress;
-            complete = false;
-            recorded = false;
-            moveTo(transferring(status));
-            handed = false;
-            try {
-                const local = await openLocal();
-                if (!live())
-                    return;
-                await ensureAuthorization();
-                if (!live())
-                    return;
-                await discoverRooms(local, progress, attempt, live);
-            }
-            catch {
-                progress.complete = false;
-                if (attempt === 'opened' && !handed)
-                    progress.reachable = false;
-            }
-            finally {
-                gate.release();
-                notifyReady();
-            }
-            if (!live())
-                return;
-            if (attempt !== 'opened') {
-                await finishOpening(progress, live);
-                return;
-            }
-            if (handed || closed || progress.reachable)
-                return;
-            underway = null;
-            opened = null;
-            journal.record('connection reopen');
-            await rest(progress, live);
-            options.adapter.roomStream?.reopen();
-        });
-    }
-    function rediscover(scope) {
-        return task(OPENING_LANE, async (live) => {
-            if (!live() || !socketOpen)
-                return;
-            const progress = { complete: true, reachable: true };
-            const gate = discover();
-            moveTo(transferring(status));
-            try {
-                const local = await openLocal();
-                if (!live())
-                    return;
-                await ensureAuthorization();
-                if (!live())
-                    return;
-                await discoverRooms(local, progress, 'authorized', live, scope);
-            }
-            catch {
-                progress.complete = false;
-            }
-            finally {
-                gate.release();
-                notifyReady();
-            }
-            if (!live())
-                return;
-            if (!progress.complete)
-                complete = false;
-            await rest(progress, live);
-        });
-    }
-    function closedSocket(revoked, lost) {
-        const opened = socketOpen;
-        socketOpen = false;
-        if (lost) {
-            reads.lost();
-            conversations.lost();
-        }
-        if (revoked) {
-            void refuse('revoked-authorization');
-            return;
-        }
-        complete = false;
-        if (streamed !== null)
-            streamed.complete = false;
-        moveTo({
-            ...status,
-            state: status.state === 'synced' ? 'syncing' : status.state,
-            providerUnreachable: status.providerUnreachable || !opened,
-        });
-    }
-    function applyOpening(expired) {
-        const progress = underway?.generation === generation ? underway.progress : null;
-        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) {
-                await replacing;
-                await rest(cycle, live);
-                return;
-            }
-            await roomsCarried([...expired, ...reloading]);
-            if (!live())
-                return;
-            try {
-                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);
-                        }
-                    }
+                    if (refusedForSpace(error))
+                        filled(runtime);
+                    throw error;
                 }
-                const failed = reloaded.find((outcome) => outcome.status === 'rejected');
-                if (failed !== undefined)
-                    throw failed.reason;
-            }
-            catch {
-                progress.complete = false;
-                progress.reachable = false;
-            }
-            if (live())
-                await finishOpening(progress, live);
-        });
-    }
-    function owedReloads(expired) {
-        const reloading = [...discovered.values()]
-            .filter((room) => replicas.has(room.locator) &&
-            !expired.includes(room.locator) &&
-            (owed.has(room.locator) || revoked(room.locator)))
-            .map((room) => room.locator);
-        owed.clear();
-        for (const locator of reloading)
-            catching.add(locator);
-        readSide.recover();
-        return reloading;
-    }
-    async function reloadNow(replaced, progress) {
-        try {
-            const local = await openLocal();
-            return await Promise.allSettled([...discovered.values()]
-                .filter((room) => replicas.has(room.locator) && replaced(room))
-                .map((room) => roomTask(room.locator, (live) => reload(room, local, progress, live))));
-        }
-        catch {
-            progress.reachable = false;
-            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' });
-            }
-        }
-    }
-    function submitLater(locator) {
-        if (localSaves)
-            return;
-        void recovery.attempt(`submit ${locator}`, (signal) => submitPass(locator, signal));
-    }
-    async function submitPass(locator, signal) {
-        const room = discovered.get(locator);
-        if (closed || stopping || discoveryPaused || room === undefined)
-            return 'done';
-        const progress = { complete: true, reachable: true };
-        let next;
-        try {
-            await ensureAuthorization();
-            if (authorization === undefined)
-                return 'done';
-            next = await submitRoom(room, await openLocal(), authorization, progress, signal);
-        }
-        catch {
-            progress.reachable = false;
-            next = 'again';
-        }
-        if (signal.aborted)
-            return 'done';
-        await rest(progress);
-        return next === 'again' && !socketOpen ? 'done' : next;
-    }
-    function repairLater(locator, when) {
-        if (!socketOpen || repairing.has(locator))
-            return;
-        void recovery.attempt(`repair ${locator}`, (signal) => repairPass(locator, signal), when);
-    }
-    async function repairPass(locator, signal) {
-        const room = discovered.get(locator);
-        if (!socketOpen || closed || stopping || discoveryPaused || !stale.has(locator))
-            return 'done';
-        if (room === undefined || room.replica.admission !== 'admitted')
-            return 'done';
-        const progress = { complete: true, reachable: true };
-        repairing.add(locator);
-        try {
-            const local = await openLocal();
-            await roomTask(locator, async (live) => {
-                const current = () => live() && !signal.aborted;
-                if (!current() || authorization === undefined)
-                    return;
-                const withheld = await Promise.race([
-                    advance(room, local, authorization, current),
-                    abandonedOn(signal),
-                ]);
-                if (withheld !== null && current())
-                    await withhold(withheld, room, local, progress);
-            });
-        }
-        catch {
-            stale.add(locator);
-            progress.reachable = false;
-        }
-        finally {
-            repairing.delete(locator);
-        }
-        if (signal.aborted)
-            return 'done';
-        await rest(progress);
-        if (!stale.has(locator)) {
-            if ((replicas.get(locator)?.queue.length ?? 0) > 0)
-                submitLater(locator);
-            return 'done';
-        }
-        if (!repairable.has(locator))
-            return 'done';
-        const reset = repairable.get(locator);
-        return reset === undefined ? 'again' : { at: Date.parse(reset) };
-    }
-    function resendLater() {
-        if (!socketOpen)
-            return;
-        void recovery.attempt('resend', resendPass, { again: true });
-    }
-    async function resendPass(signal) {
-        if (!socketOpen || closed || stopping || discoveryPaused)
-            return 'done';
-        const reading = { complete: true, reachable: true };
-        try {
-            await conversations.resend(reading);
-        }
-        catch {
-            reading.reachable = false;
-        }
-        if (signal.aborted)
-            return 'done';
-        return reading.reachable && reading.complete ? 'done' : 'again';
-    }
-    function submitAll() {
-        for (const [locator, replica] of replicas) {
-            if (replica.queue.length > 0)
-                submitLater(locator);
-        }
-    }
-    async function finishOpening(progress, live) {
-        try {
-            if (!live()) {
-                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)
-                await conversations.resend(reading);
-            if (progress.reachable)
-                void recovery.attempt('calls', resendCalls);
-            if (!reading.reachable) {
-                progress.reachable = false;
-                resendLater();
-            }
-        }
-        catch {
-            progress.complete = false;
-        }
-        finally {
-            if (live()) {
-                complete = progress.complete;
-                await rest(progress, live);
-            }
-        }
-    }
-    async function rest(progress, live = () => !closed) {
-        if (!live())
-            return;
-        let lastCompleted = status.lastCompleted;
-        let synced = complete && stale.size === 0 && !pending();
-        if (synced && !recorded) {
-            const completedAt = new Date().toISOString();
-            try {
-                await (await openLocal()).complete(completedAt);
-                if (!live())
-                    return;
-                recorded = true;
-                lastCompleted = completedAt;
-            }
-            catch {
-                synced = false;
-            }
-        }
-        moveTo({
-            state: pending() ? 'pending' : synced && complete ? 'synced' : 'syncing',
-            lastCompleted,
-            providerUnreachable: !progress.reachable,
-            ...attention(),
-        });
-    }
-    function discover() {
-        let release = () => { };
-        const done = new Promise((resolve) => {
-            release = resolve;
-        });
-        discovering = { generation, 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.confirmed.record.replica.selection !== room.replica.selection ||
-                    options.adapter.reached(locator, held.confirmed.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));
-            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);
-                });
-            }
-            catch {
-                stale.add(locator);
-            }
-            finally {
-                if (during === null)
-                    await rest(progress, live);
-            }
-        });
-    }
-    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)
-            return;
-        withdrawStream = stream.observe((event) => {
-            if (closed || stopping)
-                return;
-            if (event.kind === 'opened') {
-                socketOpen = true;
-                generation += 1;
-                reads.opened();
-                conversations.reopened();
-                recovery.resume();
-                void sync('opened');
-            }
-            else if (event.kind === 'closed')
-                closedSocket(event.revoked, event.lost);
-            else if (event.kind === 'opening')
-                void applyOpening(event.expired);
-            else if (event.kind === 'authority-changed')
-                void rediscover(event.scope);
-            else
-                void applyRoom(event.locator, event.roomVersion);
-        }, receipts);
-    }
-    function writesHeld() {
-        return serviceMode === 'write-halted' || haltedRefusal;
-    }
-    function signalled(mode) {
-        if (closed)
-            return;
-        if (mode === 'open')
-            openSignals += 1;
-        const releasing = mode === 'open' && (haltedRefusal || serviceMode === 'write-halted');
-        if (mode === 'open')
-            haltedRefusal = false;
-        if (mode !== serviceMode) {
-            serviceMode = mode;
-            queueReadiness();
-            journal.record(`service mode ${mode}`);
-            for (const listener of serviceModeListeners)
-                listener(mode);
-        }
-        if (releasing)
-            submitAll();
-    }
-    function observeConversations() {
-        const stream = options.adapter.conversations;
-        if (stream === undefined || withdrawConversations !== undefined)
-            return;
-        withdrawConversations = stream.observe((event) => {
-            if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted')
-                queueReadiness();
-            if (conversations.receive(event)) {
-                void ready.then(scheduleCurrency);
-                return;
-            }
-            if (event.kind !== 'gap' || conversations.current())
-                return;
-            show();
-            scheduleCurrency();
-        });
-    }
-    function scheduleCurrency() {
-        if (currencyQueued === generation || closed || stopping)
-            return;
-        currencyQueued = generation;
-        void task(CONVERSATION_LANE, runCurrency);
-    }
-    async function runCurrency(live) {
-        if (currencyQueued === generation)
-            currencyQueued = null;
-        if (!live())
-            return;
-        await conversations.reconcile();
-        if (conversations.current()) {
-            show();
-            return;
-        }
-        const progress = { complete: false, reachable: !status.providerUnreachable };
-        moveTo(transferring(status));
-        try {
-            await conversations.catchUp(progress);
-        }
-        catch {
-            progress.reachable = false;
-        }
-        await rest(progress, live);
-    }
-    function close() {
-        if (closed)
-            return;
-        closed = true;
-        if (rechecking !== null)
-            clearInterval(rechecking);
-        readinessWatches.clear();
-        withdrawStream?.();
-        withdrawStream = undefined;
-        withdrawConversations?.();
-        withdrawConversations = undefined;
-        withdrawServiceMode?.();
-        conversations.close();
-        void recovery.retire();
-        store?.close();
-        void opening?.then((opened) => {
-            opened.close();
-        }, () => { });
-        roomListeners.clear();
-        refusalListeners.clear();
-        storageLossListeners.clear();
-        statusListeners.clear();
-        serviceModeListeners.clear();
-        memberListeners.clear();
-        readSide.close();
-        queueSubscriptions.clear();
-        roomDraftListeners.clear();
-        presentationListeners.clear();
-    }
-    async function stop() {
-        stopping = true;
-        await recovery.retire();
-        await Promise.all(working);
-        await mutations;
-        close();
-    }
-    const withdrawServiceMode = options.adapter.serviceMode?.observe(signalled);
-    observeConversations();
-    options.signal?.addEventListener('abort', close, { once: true });
-    if (options.signal?.aborted)
-        close();
-    observeStream();
-    void openLocal().then(() => {
-        if (capabilities.length > 0)
-            notifyReady();
-    }, () => {
-        notifyReady();
-    });
-    if (options.adapter.roomStream === undefined)
-        void sync('unstreamed');
-    function planned(input, reach) {
-        const plan = planOf(input, roomFacts(reach), planReach(reach));
-        const named = plan.paths !== null &&
-            plan.rooms !== null &&
-            plan.paths.length * plan.rooms.length <= MAXIMUM_WINDOW;
-        return plan.limit === null && named ? plan : { ...plan, limit: capped(plan.limit) };
-    }
-    function watchPlan(plan, deliver) {
-        let seeded = false;
-        let pending = true;
-        const shown = () => {
-            const seed = seeds.get(plan.key);
-            if (seed === undefined || seeded || !pending)
-                return;
-            seeded = true;
-            deliver(seededResult(seed));
-        };
-        const watchers = seedWatchers.get(plan.key) ?? new Set();
-        seedWatchers.set(plan.key, watchers);
-        watchers.add(shown);
-        const stop = readSide.watch(plan, identityOf(plan), () => {
-            const cover = covered(plan);
-            awaitPreparation(cover);
-            return seedBehind(plan, cover);
-        }, (message) => {
-            const answered = message;
-            pending = whole(answered) && 'pending' in answered.result;
-            if (pending && seeds.has(plan.key)) {
-                shown();
-                return;
-            }
-            seeded = false;
-            deliver(message);
-        });
-        return () => {
-            watchers.delete(shown);
-            if (watchers.size === 0)
-                seedWatchers.delete(plan.key);
-            stop();
-        };
-    }
-    async function searched(input, reach) {
-        const asked = searchPlanOf(input);
-        const plan = { ...asked, limit: capped(asked.limit) };
-        const filter = filterOf(plan.documents ?? {}, roomFacts(reach), planReach(reach));
-        for (;;) {
-            const cover = covered(filter);
-            awaitPreparation(cover);
-            const pending = 'pending' in cover ? [...cover.pending] : [];
-            const awaited = new Set('pending' in cover ? cover.pending.map(({ room }) => room) : []);
-            const held = covered({
-                ...filter,
-                rooms: reachedRooms(filter).filter((room) => !awaited.has(room)),
-            });
-            const covering = 'pending' in held ? [] : held.coverage.rooms;
-            const unindexed = covering
-                .filter(({ room }) => !searchIndex.rooms().has(room))
-                .map(({ room }) => room);
-            for (const room of unindexed)
-                pending.push({ room, awaits: 'index' });
-            const listed = conversations.searchable();
-            const named = reach !== null && !reach.conversations
-                ? []
-                : (plan.conversations ?? listed).filter((one) => listed.includes(one) && conversations.acquired(one));
-            const waiting = named.filter((one) => !searchIndex.conversations().has(one));
-            for (const conversation of waiting)
-                pending.push({ conversation, awaits: 'index' });
-            if (unindexed.length > 0 || waiting.length > 0)
-                index(unindexed, waiting);
-            const complete = pending.length === 0 && !('pending' in cover);
-            const answering = complete
-                ? filter
-                : {
-                    ...filter,
-                    rooms: covering
-                        .filter(({ room }) => searchIndex.rooms().has(room))
-                        .map(({ room }) => room),
-                };
-            const answered = covered(answering);
-            if ('pending' in answered)
-                continue;
-            const searchedConversations = named.filter((one) => searchIndex.conversations().has(one));
-            await readSide.settled();
-            const seen = searchIndex.changes();
-            await searchIndex.caughtUp();
-            const selected = roomsAlone(answering) ? null : await rowsQuery(answering);
-            if (selected !== null && 'pending' in selected)
-                continue;
-            if (searchIndex.changes() !== seen ||
-                JSON.stringify(covered(answering)) !== JSON.stringify(answered))
-                continue;
-            const hits = searchIndex.search(plan, selected === null ? null : selected.documents, searchedConversations, answering.rooms === null ? null : new Set(answering.rooms), plan.collection
-                ? new Map(answered.coverage.rooms.map(({ room }) => [
-                    room,
-                    replicas.get(room)?.confirmed.record.typedSelection?.roots ?? [],
-                ]))
-                : null);
-            const coverage = {
-                rooms: answered.coverage.rooms,
-                conversations: searchedConversations,
-                index: searchIndex.generation(),
-                overlay: answered.coverage.overlay,
-            };
-            return complete
-                ? { ...hits, coverage }
-                : { pending, documents: hits.documents, messages: hits.messages, coverage };
-        }
-    }
-    const watch = (topic, input, deliver) => {
-        if (topic === 'room-drafts') {
-            const listener = { notify: deliver, ready: false };
-            roomDraftListeners.add(listener);
-            void exclusive(async () => {
-                await openLocal();
-                if (closed || !roomDraftListeners.has(listener))
-                    return;
-                listener.ready = true;
-            }).then(() => {
-                if (closed || !listener.ready || !roomDraftListeners.has(listener))
-                    return;
-                listener.notify(snapshotRoomDrafts());
-            }, () => { });
-            return () => {
-                roomDraftListeners.delete(listener);
-            };
-        }
-        if (topic === 'conversation') {
-            return conversations.watch(input[0], input[1], deliver);
-        }
-        if (topic === 'conversations')
-            return conversations.watchList(deliver);
-        if (topic === 'agents')
-            return conversations.watchAgents(deliver);
-        if (topic === 'presentation') {
-            const listener = {
-                app: input[0],
-                notify: deliver,
-                ready: false,
-            };
-            presentationListeners.add(listener);
-            void exclusive(async () => {
-                await openLocal();
-            }).then(() => {
-                if (closed || !presentationListeners.has(listener))
-                    return;
-                listener.ready = true;
-                listener.notify(presentationOf(listener.app));
-            }, () => { });
-            return () => {
-                presentationListeners.delete(listener);
-            };
-        }
-        if (topic === 'readiness') {
-            return watchReadiness({ target: '', code: 'stored', capacity: null, search: 'unused' }, null, deliver);
-        }
-        if (topic === 'rooms') {
-            roomListeners.add(deliver);
-            deliver(listed());
-            return () => {
-                roomListeners.delete(deliver);
-            };
-        }
-        if (topic === 'connection-refusal') {
-            refusalListeners.add(deliver);
-            deliver(refusal);
-            return () => {
-                refusalListeners.delete(deliver);
-            };
-        }
-        if (topic === 'storage-loss') {
-            storageLossListeners.add(deliver);
-            deliver(storageLoss);
-            return () => {
-                storageLossListeners.delete(deliver);
-            };
-        }
-        if (topic === 'sync-status') {
-            statusListeners.add(deliver);
-            deliver(shown);
-            return () => {
-                statusListeners.delete(deliver);
-            };
-        }
-        if (topic === 'service-mode') {
-            serviceModeListeners.add(deliver);
-            deliver(serviceMode);
-            return () => {
-                serviceModeListeners.delete(deliver);
-            };
-        }
-        if (topic === 'member') {
-            memberListeners.add(deliver);
-            deliver(member);
-            return () => {
-                memberListeners.delete(deliver);
-            };
-        }
-        if (topic === 'queue') {
-            const queue = { locator: input[0], notify: deliver };
-            queueSubscriptions.add(queue);
-            queue.notify(entriesOf(queue.locator));
-            return () => {
-                queueSubscriptions.delete(queue);
-            };
-        }
-        return watchPlan(planned(input[0], null), deliver);
-    };
-    const md = {
-        loaded() {
-            return openLocal().then(() => undefined);
-        },
-        rooms() {
-            return listed();
-        },
-        query: ((input) => rowsQuery(planned(input, null))),
-        search: (input) => searched(input, null),
-        types(locator) {
-            return {
-                collection: modelTypes(modelOf(locator)),
-                typedSelection: rooms.get(locator)?.typedSelection === undefined ||
-                    rooms.get(locator)?.typedSelection === null
-                    ? null
-                    : modelTypes(modelOf(locator, 'typed-selection')),
-            };
-        },
-        roomDraft: {
-            list() {
-                return exclusive(async () => {
-                    await openLocal();
-                    return snapshotRoomDrafts();
-                }).then((listed) => {
-                    publishRoomDrafts(true);
-                    return listed;
-                });
-            },
-            read(room, path) {
-                const record = roomDrafts.get(room)?.get(path);
-                return record === undefined ? null : roomDraftOf(record);
-            },
-            write(room, path, revision, input) {
-                return exclusive(async () => {
-                    const parts = readParts(input);
-                    if (path === '' || normalize(path) !== path)
-                        throw runtimeError('room-draft-malformed');
-                    const local = await openLocal();
-                    const current = roomDrafts.get(room)?.get(path);
-                    if ((current?.revision ?? null) !== revision) {
-                        return staleWrite(current === undefined ? null : roomDraftOf(current));
-                    }
-                    const file = parts.file === undefined
-                        ? undefined
-                        : await heldFile(parts.file.blob, binaryBase(replicas.get(room)?.visible, path));
-                    const record = {
-                        locator: room,
-                        path,
-                        revision: roomDraftRevision(),
-                        parts: held(current?.parts, parts, file),
-                        returned: current?.returned ?? null,
-                    };
-                    await local.keepRoomDraft(record);
-                    rememberRoomDraft(record);
-                    publishChangeSet(changeSet(room, null, null, { drafts: [path] }));
-                    return { outcome: 'written', roomDraft: roomDraftOf(record) };
-                });
-            },
-            discard(room, path, revision) {
-                return exclusive(async () => {
-                    const local = await openLocal();
-                    const current = roomDrafts.get(room)?.get(path);
-                    if (current === undefined || current.revision !== revision) {
-                        return staleWrite(current === undefined ? null : roomDraftOf(current));
-                    }
-                    await local.discardRoomDraft(room, path);
-                    forgetRoomDraft(room, path);
-                    publishChangeSet(changeSet(room, null, null, { drafts: [path] }));
-                    moveTo({ ...status, ...attention() });
-                    return { outcome: 'written', roomDraft: null };
-                });
             },
         },
-        conversation: conversations.surface,
-        chatDraft: conversations.chatDraft,
-        presentation: {
-            read(app) {
-                return exclusive(async () => {
-                    await openLocal();
-                    return presentationOf(app);
-                });
-            },
-            write(app, value) {
-                return keepPresentation(app, () => structuredClone(value));
+        roomTypes,
+        builtIn,
+        typedPaths,
+        persistence: shell.persistence,
+        opening: (local) => open(runtime, local),
+        unpublished(error) {
+            journal.record(`publication failed ${error instanceof Error ? error.name : 'unknown'}`);
+        },
+        changed: (set) => publishChangeSet(runtime, set),
+        deliverReadiness: (owed) => deliverOwedReadiness(runtime, owed),
+        spaceFreed: () => spaceFreed(runtime),
+    });
+    const recovery = (options.recovery ?? createRecovery()).scope(ROOM_ATTEMPTS);
+    const runtime = {
+        store,
+        socket,
+        journal,
+        recovery,
+        shell,
+        localSaves: adapter.localSaves === true,
+        roomTypes,
+        builtIn,
+        typedPaths,
+        usableWhenHeld: options.usableWhenHeld ?? [],
+        build: options.build ?? '',
+        conversations: createConversationStore({
+            call: (name, input) => invokeAction(runtime, name, input),
+            history: (request) => readConversationHistory(runtime, request),
+            durably: store.durably,
+            local: store.open,
+            again: () => {
+                void socket.ready.then(() => scheduleCurrency(runtime));
             },
-            edit(app, members) {
-                return keepPresentation(app, (held) => Object.fromEntries([
-                    ...Object.entries(plain(held) ? held : {}).filter(([member]) => !Object.hasOwn(members, member)),
-                    ...Object.entries(structuredClone(members)).filter(([, value]) => value !== null),
-                ]));
+            settled: () => {
+                show(runtime);
             },
-        },
-        save(room, named, writtenBy) {
-            return exclusive(() => saveRoomDrafts(room, named, writtenBy));
-        },
-        saveParts(room, parts, writtenBy) {
-            return exclusive(() => saveParts(room, parts, writtenBy));
-        },
-        history(locator, path, query) {
-            return readHistory(locator, path, query);
-        },
-        binaryFile: {
-            read: readBinaryPath,
-            link: linkBinaryPath,
-            readReference: readBinaryReference,
-        },
-        call(name, input) {
-            return recoveredAction(name, input);
-        },
-        reached(locator, roomVersion, path) {
-            return path === undefined
-                ? reachedBy(locator, roomVersion)
-                : writtenAfter(locator, roomVersion, path);
-        },
-        log() {
-            return journal.export();
-        },
-        persistence() {
-            return persistence === 'granted';
-        },
-        async retry() {
-            journal.record('retry');
-            unindexable.clear();
-            queueReadiness();
-            resume();
-        },
-        observe: observing(watch),
-        async reauthorize() {
-            if (refusal === null || !refusal.reauthorizationOffered)
-                return;
-            journal.record('connection reauthorize');
-            await Promise.all([...lanes.values()]
-                .filter((held) => held.generation === generation)
-                .map((held) => held.chain));
-            await mutations;
-            authorization = undefined;
-            discoveryPaused = false;
-            if (options.adapter.roomStream === undefined)
-                await sync('unstreamed');
-            else
-                await task(OPENING_LANE, ensureAuthorization);
-        },
-    };
-    const reachable = {
-        md,
-        watch,
-        referrerScope: (referrer) => options.adapter.referrerScope(referrer),
-        plan: planned,
-        query: (plan) => rowsQuery(plan),
-        watchPlan,
-        search: searched,
-        watchReadiness,
-    };
-    return {
-        md,
-        seed,
-        stop,
-        lose: loseRooms,
-        watch,
-        persisted(answer) {
-            if (answer === persistence)
-                return;
-            persistence = answer;
-            journal.record(`persistence ${answer}`);
-            queueReadiness();
-        },
-        within: (reach, port) => narrowed(reachable, reach, port),
+            stream: socket.conversations,
+            publish: store.changed,
+            online: socket.reached,
+            full: store.space.full,
+            closed: socket.closed,
+            unanswered: () => resendLater(runtime),
+        }),
+        liveQueries: createLiveQueries((plan, cover) => answeredPlan(runtime, plan, cover), store.covering),
+        figures: createFigures({
+            cover: () => figuresCover(runtime),
+            rooms: (rooms, since) => roomTallies(runtime, rooms, since),
+            conversations: (conversations, since) => store.ask({ kind: 'conversation.tallies', conversations, since }),
+        }),
+        lastAnswers: readAnswers({
+            database: store,
+            build: options.build ?? '',
+            unkept: adapter.unkeptReads ?? [],
+            leading: adapter.leadingReads ?? [],
+            recovery: recovery.scope(),
+            call: (name, input) => called(runtime, name, input),
+            online: socket.reached,
+            closed: socket.closed,
+            full: store.space.full,
+            filled: () => filled(runtime),
+        }),
+        settle: (...held) => settle(runtime, ...held),
+        scoped: (...held) => scoped(runtime, ...held),
+        submitLater: (locator) => submitLater(runtime, locator),
+        unpair: (local) => unpair(runtime, local),
+        advanced: (...held) => advanced(runtime, ...held),
+        withhold: (...held) => withhold(runtime, ...held),
     };
+    start(runtime, options.signal);
+    return composedRuntime(runtime);
 }